Add missing-END_CATCH detection/protection (to gdb's TRY/CATCH/END_CATCH)
[deliverable/binutils-gdb.git] / gdb / gdbarch.sh
CommitLineData
66b43ecb 1#!/bin/sh -u
104c1213
JM
2
3# Architecture commands for GDB, the GNU debugger.
79d45cd4 4#
61baf725 5# Copyright (C) 1998-2017 Free Software Foundation, Inc.
104c1213
JM
6#
7# This file is part of GDB.
8#
9# This program is free software; you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
50efebf8 11# the Free Software Foundation; either version 3 of the License, or
104c1213
JM
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
50efebf8 20# along with this program. If not, see <http://www.gnu.org/licenses/>.
104c1213 21
6e2c7fa1 22# Make certain that the script is not running in an internationalized
d8864532 23# environment.
0e05dfcb
DJ
24LANG=C ; export LANG
25LC_ALL=C ; export LC_ALL
d8864532
AC
26
27
59233f88
AC
28compare_new ()
29{
30 file=$1
66b43ecb 31 if test ! -r ${file}
59233f88
AC
32 then
33 echo "${file} missing? cp new-${file} ${file}" 1>&2
50248794 34 elif diff -u ${file} new-${file}
59233f88
AC
35 then
36 echo "${file} unchanged" 1>&2
37 else
38 echo "${file} has changed? cp new-${file} ${file}" 1>&2
39 fi
40}
41
42
43# Format of the input table
97030eea 44read="class returntype function formal actual staticdefault predefault postdefault invalid_p print garbage_at_eol"
c0e8c252
AC
45
46do_read ()
47{
34620563
AC
48 comment=""
49 class=""
c9023fb3
PA
50 # On some SH's, 'read' trims leading and trailing whitespace by
51 # default (e.g., bash), while on others (e.g., dash), it doesn't.
52 # Set IFS to empty to disable the trimming everywhere.
53 while IFS='' read line
34620563
AC
54 do
55 if test "${line}" = ""
56 then
57 continue
58 elif test "${line}" = "#" -a "${comment}" = ""
f0d4cc9e 59 then
34620563
AC
60 continue
61 elif expr "${line}" : "#" > /dev/null
f0d4cc9e 62 then
34620563
AC
63 comment="${comment}
64${line}"
f0d4cc9e 65 else
3d9a5942
AC
66
67 # The semantics of IFS varies between different SH's. Some
ea480a30
SM
68 # treat ``;;' as three fields while some treat it as just two.
69 # Work around this by eliminating ``;;'' ....
70 line="`echo "${line}" | sed -e 's/;;/; ;/g' -e 's/;;/; ;/g'`"
3d9a5942 71
ea480a30 72 OFS="${IFS}" ; IFS="[;]"
34620563
AC
73 eval read ${read} <<EOF
74${line}
75EOF
76 IFS="${OFS}"
77
283354d8
AC
78 if test -n "${garbage_at_eol}"
79 then
80 echo "Garbage at end-of-line in ${line}" 1>&2
81 kill $$
82 exit 1
83 fi
84
3d9a5942
AC
85 # .... and then going back through each field and strip out those
86 # that ended up with just that space character.
87 for r in ${read}
88 do
89 if eval test \"\${${r}}\" = \"\ \"
90 then
91 eval ${r}=""
92 fi
93 done
94
a72293e2
AC
95 case "${class}" in
96 m ) staticdefault="${predefault}" ;;
97 M ) staticdefault="0" ;;
98 * ) test "${staticdefault}" || staticdefault=0 ;;
99 esac
06b25f14 100
ae45cd16
AC
101 case "${class}" in
102 F | V | M )
103 case "${invalid_p}" in
34620563 104 "" )
f7968451 105 if test -n "${predefault}"
34620563
AC
106 then
107 #invalid_p="gdbarch->${function} == ${predefault}"
ae45cd16 108 predicate="gdbarch->${function} != ${predefault}"
f7968451
AC
109 elif class_is_variable_p
110 then
111 predicate="gdbarch->${function} != 0"
112 elif class_is_function_p
113 then
114 predicate="gdbarch->${function} != NULL"
34620563
AC
115 fi
116 ;;
ae45cd16 117 * )
1e9f55d0 118 echo "Predicate function ${function} with invalid_p." 1>&2
ae45cd16
AC
119 kill $$
120 exit 1
121 ;;
122 esac
34620563
AC
123 esac
124
125 # PREDEFAULT is a valid fallback definition of MEMBER when
126 # multi-arch is not enabled. This ensures that the
127 # default value, when multi-arch is the same as the
128 # default value when not multi-arch. POSTDEFAULT is
129 # always a valid definition of MEMBER as this again
130 # ensures consistency.
131
72e74a21 132 if [ -n "${postdefault}" ]
34620563
AC
133 then
134 fallbackdefault="${postdefault}"
72e74a21 135 elif [ -n "${predefault}" ]
34620563
AC
136 then
137 fallbackdefault="${predefault}"
138 else
73d3c16e 139 fallbackdefault="0"
34620563
AC
140 fi
141
142 #NOT YET: See gdbarch.log for basic verification of
143 # database
144
145 break
f0d4cc9e 146 fi
34620563 147 done
72e74a21 148 if [ -n "${class}" ]
34620563
AC
149 then
150 true
c0e8c252
AC
151 else
152 false
153 fi
154}
155
104c1213 156
f0d4cc9e
AC
157fallback_default_p ()
158{
72e74a21
JB
159 [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
160 || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
f0d4cc9e
AC
161}
162
163class_is_variable_p ()
164{
4a5c6a1d
AC
165 case "${class}" in
166 *v* | *V* ) true ;;
167 * ) false ;;
168 esac
f0d4cc9e
AC
169}
170
171class_is_function_p ()
172{
4a5c6a1d
AC
173 case "${class}" in
174 *f* | *F* | *m* | *M* ) true ;;
175 * ) false ;;
176 esac
177}
178
179class_is_multiarch_p ()
180{
181 case "${class}" in
182 *m* | *M* ) true ;;
183 * ) false ;;
184 esac
f0d4cc9e
AC
185}
186
187class_is_predicate_p ()
188{
4a5c6a1d
AC
189 case "${class}" in
190 *F* | *V* | *M* ) true ;;
191 * ) false ;;
192 esac
f0d4cc9e
AC
193}
194
195class_is_info_p ()
196{
4a5c6a1d
AC
197 case "${class}" in
198 *i* ) true ;;
199 * ) false ;;
200 esac
f0d4cc9e
AC
201}
202
203
cff3e48b
JM
204# dump out/verify the doco
205for field in ${read}
206do
207 case ${field} in
208
209 class ) : ;;
c4093a6a 210
c0e8c252
AC
211 # # -> line disable
212 # f -> function
213 # hiding a function
2ada493a
AC
214 # F -> function + predicate
215 # hiding a function + predicate to test function validity
c0e8c252
AC
216 # v -> variable
217 # hiding a variable
2ada493a
AC
218 # V -> variable + predicate
219 # hiding a variable + predicate to test variables validity
c0e8c252
AC
220 # i -> set from info
221 # hiding something from the ``struct info'' object
4a5c6a1d
AC
222 # m -> multi-arch function
223 # hiding a multi-arch function (parameterised with the architecture)
224 # M -> multi-arch function + predicate
225 # hiding a multi-arch function + predicate to test function validity
cff3e48b 226
cff3e48b
JM
227 returntype ) : ;;
228
c0e8c252 229 # For functions, the return type; for variables, the data type
cff3e48b
JM
230
231 function ) : ;;
232
c0e8c252
AC
233 # For functions, the member function name; for variables, the
234 # variable name. Member function names are always prefixed with
235 # ``gdbarch_'' for name-space purity.
cff3e48b
JM
236
237 formal ) : ;;
238
c0e8c252
AC
239 # The formal argument list. It is assumed that the formal
240 # argument list includes the actual name of each list element.
241 # A function with no arguments shall have ``void'' as the
242 # formal argument list.
cff3e48b
JM
243
244 actual ) : ;;
245
c0e8c252
AC
246 # The list of actual arguments. The arguments specified shall
247 # match the FORMAL list given above. Functions with out
248 # arguments leave this blank.
cff3e48b 249
0b8f9e4d 250 staticdefault ) : ;;
c0e8c252
AC
251
252 # To help with the GDB startup a static gdbarch object is
0b8f9e4d
AC
253 # created. STATICDEFAULT is the value to insert into that
254 # static gdbarch object. Since this a static object only
255 # simple expressions can be used.
cff3e48b 256
0b8f9e4d 257 # If STATICDEFAULT is empty, zero is used.
c0e8c252 258
0b8f9e4d 259 predefault ) : ;;
cff3e48b 260
10312cc4
AC
261 # An initial value to assign to MEMBER of the freshly
262 # malloc()ed gdbarch object. After initialization, the
263 # freshly malloc()ed object is passed to the target
264 # architecture code for further updates.
cff3e48b 265
0b8f9e4d
AC
266 # If PREDEFAULT is empty, zero is used.
267
10312cc4
AC
268 # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
269 # INVALID_P are specified, PREDEFAULT will be used as the
270 # default for the non- multi-arch target.
271
272 # A zero PREDEFAULT function will force the fallback to call
273 # internal_error().
f0d4cc9e
AC
274
275 # Variable declarations can refer to ``gdbarch'' which will
276 # contain the current architecture. Care should be taken.
0b8f9e4d
AC
277
278 postdefault ) : ;;
279
280 # A value to assign to MEMBER of the new gdbarch object should
10312cc4
AC
281 # the target architecture code fail to change the PREDEFAULT
282 # value.
0b8f9e4d
AC
283
284 # If POSTDEFAULT is empty, no post update is performed.
285
286 # If both INVALID_P and POSTDEFAULT are non-empty then
287 # INVALID_P will be used to determine if MEMBER should be
288 # changed to POSTDEFAULT.
289
10312cc4
AC
290 # If a non-empty POSTDEFAULT and a zero INVALID_P are
291 # specified, POSTDEFAULT will be used as the default for the
292 # non- multi-arch target (regardless of the value of
293 # PREDEFAULT).
294
f0d4cc9e
AC
295 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
296
be7811ad 297 # Variable declarations can refer to ``gdbarch'' which
db446970
AC
298 # will contain the current architecture. Care should be
299 # taken.
cff3e48b 300
c4093a6a 301 invalid_p ) : ;;
cff3e48b 302
0b8f9e4d 303 # A predicate equation that validates MEMBER. Non-zero is
c0e8c252 304 # returned if the code creating the new architecture failed to
0b8f9e4d
AC
305 # initialize MEMBER or the initialized the member is invalid.
306 # If POSTDEFAULT is non-empty then MEMBER will be updated to
307 # that value. If POSTDEFAULT is empty then internal_error()
308 # is called.
309
310 # If INVALID_P is empty, a check that MEMBER is no longer
311 # equal to PREDEFAULT is used.
312
f0d4cc9e
AC
313 # The expression ``0'' disables the INVALID_P check making
314 # PREDEFAULT a legitimate value.
0b8f9e4d
AC
315
316 # See also PREDEFAULT and POSTDEFAULT.
cff3e48b 317
cff3e48b
JM
318 print ) : ;;
319
2f9b146e
AC
320 # An optional expression that convers MEMBER to a value
321 # suitable for formatting using %s.
c0e8c252 322
0b1553bc
UW
323 # If PRINT is empty, core_addr_to_string_nz (for CORE_ADDR)
324 # or plongest (anything else) is used.
cff3e48b 325
283354d8 326 garbage_at_eol ) : ;;
0b8f9e4d 327
283354d8 328 # Catches stray fields.
cff3e48b 329
50248794
AC
330 *)
331 echo "Bad field ${field}"
332 exit 1;;
cff3e48b
JM
333 esac
334done
335
cff3e48b 336
104c1213
JM
337function_list ()
338{
cff3e48b 339 # See below (DOCO) for description of each field
34620563 340 cat <<EOF
ea480a30 341i;const struct bfd_arch_info *;bfd_arch_info;;;&bfd_default_arch_struct;;;;gdbarch_bfd_arch_info (gdbarch)->printable_name
104c1213 342#
ea480a30
SM
343i;enum bfd_endian;byte_order;;;BFD_ENDIAN_BIG
344i;enum bfd_endian;byte_order_for_code;;;BFD_ENDIAN_BIG
4be87837 345#
ea480a30 346i;enum gdb_osabi;osabi;;;GDB_OSABI_UNKNOWN
424163ea 347#
ea480a30 348i;const struct target_desc *;target_desc;;;;;;;host_address_to_string (gdbarch->target_desc)
32c9a795
MD
349
350# The bit byte-order has to do just with numbering of bits in debugging symbols
351# and such. Conceptually, it's quite separate from byte/word byte order.
ea480a30 352v;int;bits_big_endian;;;1;(gdbarch->byte_order == BFD_ENDIAN_BIG);;0
32c9a795 353
66b43ecb 354# Number of bits in a short or unsigned short for the target machine.
ea480a30 355v;int;short_bit;;;8 * sizeof (short);2*TARGET_CHAR_BIT;;0
66b43ecb 356# Number of bits in an int or unsigned int for the target machine.
ea480a30 357v;int;int_bit;;;8 * sizeof (int);4*TARGET_CHAR_BIT;;0
66b43ecb 358# Number of bits in a long or unsigned long for the target machine.
ea480a30 359v;int;long_bit;;;8 * sizeof (long);4*TARGET_CHAR_BIT;;0
66b43ecb
AC
360# Number of bits in a long long or unsigned long long for the target
361# machine.
ea480a30 362v;int;long_long_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0
205c306f
DM
363# Alignment of a long long or unsigned long long for the target
364# machine.
ea480a30 365v;int;long_long_align_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0
456fcf94 366
f9e9243a
UW
367# The ABI default bit-size and format for "half", "float", "double", and
368# "long double". These bit/format pairs should eventually be combined
369# into a single object. For the moment, just initialize them as a pair.
8da61cc4
DJ
370# Each format describes both the big and little endian layouts (if
371# useful).
456fcf94 372
ea480a30
SM
373v;int;half_bit;;;16;2*TARGET_CHAR_BIT;;0
374v;const struct floatformat **;half_format;;;;;floatformats_ieee_half;;pformat (gdbarch->half_format)
375v;int;float_bit;;;8 * sizeof (float);4*TARGET_CHAR_BIT;;0
376v;const struct floatformat **;float_format;;;;;floatformats_ieee_single;;pformat (gdbarch->float_format)
377v;int;double_bit;;;8 * sizeof (double);8*TARGET_CHAR_BIT;;0
378v;const struct floatformat **;double_format;;;;;floatformats_ieee_double;;pformat (gdbarch->double_format)
379v;int;long_double_bit;;;8 * sizeof (long double);8*TARGET_CHAR_BIT;;0
380v;const struct floatformat **;long_double_format;;;;;floatformats_ieee_double;;pformat (gdbarch->long_double_format)
456fcf94 381
53375380
PA
382# The ABI default bit-size for "wchar_t". wchar_t is a built-in type
383# starting with C++11.
ea480a30 384v;int;wchar_bit;;;8 * sizeof (wchar_t);4*TARGET_CHAR_BIT;;0
53375380 385# One if \`wchar_t' is signed, zero if unsigned.
ea480a30 386v;int;wchar_signed;;;1;-1;1
53375380 387
9b790ce7
UW
388# Returns the floating-point format to be used for values of length LENGTH.
389# NAME, if non-NULL, is the type name, which may be used to distinguish
390# different target formats of the same length.
ea480a30 391m;const struct floatformat **;floatformat_for_type;const char *name, int length;name, length;0;default_floatformat_for_type;;0
9b790ce7 392
52204a0b
DT
393# For most targets, a pointer on the target and its representation as an
394# address in GDB have the same size and "look the same". For such a
17a912b6 395# target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
52204a0b
DT
396# / addr_bit will be set from it.
397#
17a912b6 398# If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
8da614df
CV
399# also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
400# gdbarch_address_to_pointer as well.
52204a0b
DT
401#
402# ptr_bit is the size of a pointer on the target
ea480a30 403v;int;ptr_bit;;;8 * sizeof (void*);gdbarch->int_bit;;0
52204a0b 404# addr_bit is the size of a target address as represented in gdb
ea480a30 405v;int;addr_bit;;;8 * sizeof (void*);0;gdbarch_ptr_bit (gdbarch);
104c1213 406#
8da614df
CV
407# dwarf2_addr_size is the target address size as used in the Dwarf debug
408# info. For .debug_frame FDEs, this is supposed to be the target address
409# size from the associated CU header, and which is equivalent to the
410# DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
411# Unfortunately there is no good way to determine this value. Therefore
412# dwarf2_addr_size simply defaults to the target pointer size.
413#
414# dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
415# defined using the target's pointer size so far.
416#
417# Note that dwarf2_addr_size only needs to be redefined by a target if the
418# GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
419# and if Dwarf versions < 4 need to be supported.
ea480a30 420v;int;dwarf2_addr_size;;;sizeof (void*);0;gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
8da614df 421#
4e409299 422# One if \`char' acts like \`signed char', zero if \`unsigned char'.
ea480a30 423v;int;char_signed;;;1;-1;1
4e409299 424#
ea480a30
SM
425F;CORE_ADDR;read_pc;struct regcache *regcache;regcache
426F;void;write_pc;struct regcache *regcache, CORE_ADDR val;regcache, val
39d4ef09
AC
427# Function for getting target's idea of a frame pointer. FIXME: GDB's
428# whole scheme for dealing with "frames" and "frame pointers" needs a
429# serious shakedown.
ea480a30 430m;void;virtual_frame_pointer;CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset;pc, frame_regnum, frame_offset;0;legacy_virtual_frame_pointer;;0
66b43ecb 431#
ea480a30 432M;enum register_status;pseudo_register_read;struct regcache *regcache, int cookednum, gdb_byte *buf;regcache, cookednum, buf
3543a589
TT
433# Read a register into a new struct value. If the register is wholly
434# or partly unavailable, this should call mark_value_bytes_unavailable
435# as appropriate. If this is defined, then pseudo_register_read will
436# never be called.
ea480a30
SM
437M;struct value *;pseudo_register_read_value;struct regcache *regcache, int cookednum;regcache, cookednum
438M;void;pseudo_register_write;struct regcache *regcache, int cookednum, const gdb_byte *buf;regcache, cookednum, buf
61a0eb5b 439#
ea480a30 440v;int;num_regs;;;0;-1
0aba1244
EZ
441# This macro gives the number of pseudo-registers that live in the
442# register namespace but do not get fetched or stored on the target.
3d9a5942
AC
443# These pseudo-registers may be aliases for other registers,
444# combinations of other registers, or they may be computed by GDB.
ea480a30 445v;int;num_pseudo_regs;;;0;0;;0
c2169756 446
175ff332
HZ
447# Assemble agent expression bytecode to collect pseudo-register REG.
448# Return -1 if something goes wrong, 0 otherwise.
ea480a30 449M;int;ax_pseudo_register_collect;struct agent_expr *ax, int reg;ax, reg
175ff332
HZ
450
451# Assemble agent expression bytecode to push the value of pseudo-register
452# REG on the interpreter stack.
453# Return -1 if something goes wrong, 0 otherwise.
ea480a30 454M;int;ax_pseudo_register_push_stack;struct agent_expr *ax, int reg;ax, reg
175ff332 455
012b3a21
WT
456# Some targets/architectures can do extra processing/display of
457# segmentation faults. E.g., Intel MPX boundary faults.
458# Call the architecture dependent function to handle the fault.
459# UIOUT is the output stream where the handler will place information.
ea480a30 460M;void;handle_segmentation_fault;struct ui_out *uiout;uiout
012b3a21 461
c2169756
AC
462# GDB's standard (or well known) register numbers. These can map onto
463# a real register or a pseudo (computed) register or not be defined at
1200cd6e 464# all (-1).
3e8c568d 465# gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
ea480a30
SM
466v;int;sp_regnum;;;-1;-1;;0
467v;int;pc_regnum;;;-1;-1;;0
468v;int;ps_regnum;;;-1;-1;;0
469v;int;fp0_regnum;;;0;-1;;0
88c72b7d 470# Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
ea480a30 471m;int;stab_reg_to_regnum;int stab_regnr;stab_regnr;;no_op_reg_to_regnum;;0
88c72b7d 472# Provide a default mapping from a ecoff register number to a gdb REGNUM.
ea480a30 473m;int;ecoff_reg_to_regnum;int ecoff_regnr;ecoff_regnr;;no_op_reg_to_regnum;;0
88c72b7d 474# Convert from an sdb register number to an internal gdb register number.
ea480a30 475m;int;sdb_reg_to_regnum;int sdb_regnr;sdb_regnr;;no_op_reg_to_regnum;;0
ba2b1c56 476# Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
0fde2c53 477# Return -1 for bad REGNUM. Note: Several targets get this wrong.
ea480a30
SM
478m;int;dwarf2_reg_to_regnum;int dwarf2_regnr;dwarf2_regnr;;no_op_reg_to_regnum;;0
479m;const char *;register_name;int regnr;regnr;;0
9c04cab7 480
7b9ee6a8
DJ
481# Return the type of a register specified by the architecture. Only
482# the register cache should call this function directly; others should
483# use "register_type".
ea480a30 484M;struct type *;register_type;int reg_nr;reg_nr
9c04cab7 485
ea480a30 486M;struct frame_id;dummy_id;struct frame_info *this_frame;this_frame
669fac23 487# Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
064f5156 488# deprecated_fp_regnum.
ea480a30 489v;int;deprecated_fp_regnum;;;-1;-1;;0
f3be58bc 490
ea480a30
SM
491M;CORE_ADDR;push_dummy_call;struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr;function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr
492v;int;call_dummy_location;;;;AT_ENTRY_POINT;;0
493M;CORE_ADDR;push_dummy_code;CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache;sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache
57010b1c 494
7eb89530 495# Return true if the code of FRAME is writable.
ea480a30 496m;int;code_of_frame_writable;struct frame_info *frame;frame;;default_code_of_frame_writable;;0
7eb89530 497
ea480a30
SM
498m;void;print_registers_info;struct ui_file *file, struct frame_info *frame, int regnum, int all;file, frame, regnum, all;;default_print_registers_info;;0
499m;void;print_float_info;struct ui_file *file, struct frame_info *frame, const char *args;file, frame, args;;default_print_float_info;;0
500M;void;print_vector_info;struct ui_file *file, struct frame_info *frame, const char *args;file, frame, args
7c7651b2
AC
501# MAP a GDB RAW register number onto a simulator register number. See
502# also include/...-sim.h.
ea480a30
SM
503m;int;register_sim_regno;int reg_nr;reg_nr;;legacy_register_sim_regno;;0
504m;int;cannot_fetch_register;int regnum;regnum;;cannot_register_not;;0
505m;int;cannot_store_register;int regnum;regnum;;cannot_register_not;;0
eade6471
JB
506
507# Determine the address where a longjmp will land and save this address
508# in PC. Return nonzero on success.
509#
510# FRAME corresponds to the longjmp frame.
ea480a30 511F;int;get_longjmp_target;struct frame_info *frame, CORE_ADDR *pc;frame, pc
eade6471 512
104c1213 513#
ea480a30 514v;int;believe_pcc_promotion;;;;;;;
104c1213 515#
ea480a30
SM
516m;int;convert_register_p;int regnum, struct type *type;regnum, type;0;generic_convert_register_p;;0
517f;int;register_to_value;struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep;frame, regnum, type, buf, optimizedp, unavailablep;0
518f;void;value_to_register;struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf;frame, regnum, type, buf;0
9acbedc0 519# Construct a value representing the contents of register REGNUM in
2ed3c037 520# frame FRAME_ID, interpreted as type TYPE. The routine needs to
9acbedc0
UW
521# allocate and return a struct value with all value attributes
522# (but not the value contents) filled in.
ea480a30 523m;struct value *;value_from_register;struct type *type, int regnum, struct frame_id frame_id;type, regnum, frame_id;;default_value_from_register;;0
104c1213 524#
ea480a30
SM
525m;CORE_ADDR;pointer_to_address;struct type *type, const gdb_byte *buf;type, buf;;unsigned_pointer_to_address;;0
526m;void;address_to_pointer;struct type *type, gdb_byte *buf, CORE_ADDR addr;type, buf, addr;;unsigned_address_to_pointer;;0
527M;CORE_ADDR;integer_to_address;struct type *type, const gdb_byte *buf;type, buf
92ad9cd9 528
6a3a010b
MR
529# Return the return-value convention that will be used by FUNCTION
530# to return a value of type VALTYPE. FUNCTION may be NULL in which
ea42b34a
JB
531# case the return convention is computed based only on VALTYPE.
532#
533# If READBUF is not NULL, extract the return value and save it in this buffer.
534#
535# If WRITEBUF is not NULL, it contains a return value which will be
536# stored into the appropriate register. This can be used when we want
537# to force the value returned by a function (see the "return" command
538# for instance).
ea480a30 539M;enum return_value_convention;return_value;struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf;function, valtype, regcache, readbuf, writebuf
92ad9cd9 540
18648a37
YQ
541# Return true if the return value of function is stored in the first hidden
542# parameter. In theory, this feature should be language-dependent, specified
543# by language and its ABI, such as C++. Unfortunately, compiler may
544# implement it to a target-dependent feature. So that we need such hook here
545# to be aware of this in GDB.
ea480a30 546m;int;return_in_first_hidden_param_p;struct type *type;type;;default_return_in_first_hidden_param_p;;0
18648a37 547
ea480a30
SM
548m;CORE_ADDR;skip_prologue;CORE_ADDR ip;ip;0;0
549M;CORE_ADDR;skip_main_prologue;CORE_ADDR ip;ip
591a12a1
UW
550# On some platforms, a single function may provide multiple entry points,
551# e.g. one that is used for function-pointer calls and a different one
552# that is used for direct function calls.
553# In order to ensure that breakpoints set on the function will trigger
554# no matter via which entry point the function is entered, a platform
555# may provide the skip_entrypoint callback. It is called with IP set
556# to the main entry point of a function (as determined by the symbol table),
557# and should return the address of the innermost entry point, where the
558# actual breakpoint needs to be set. Note that skip_entrypoint is used
559# by GDB common code even when debugging optimized code, where skip_prologue
560# is not used.
ea480a30 561M;CORE_ADDR;skip_entrypoint;CORE_ADDR ip;ip
591a12a1 562
ea480a30
SM
563f;int;inner_than;CORE_ADDR lhs, CORE_ADDR rhs;lhs, rhs;0;0
564m;const gdb_byte *;breakpoint_from_pc;CORE_ADDR *pcptr, int *lenptr;pcptr, lenptr;0;default_breakpoint_from_pc;;0
cd6c3b4f
YQ
565
566# Return the breakpoint kind for this target based on *PCPTR.
ea480a30 567m;int;breakpoint_kind_from_pc;CORE_ADDR *pcptr;pcptr;;0;
cd6c3b4f
YQ
568
569# Return the software breakpoint from KIND. KIND can have target
570# specific meaning like the Z0 kind parameter.
571# SIZE is set to the software breakpoint's length in memory.
ea480a30 572m;const gdb_byte *;sw_breakpoint_from_kind;int kind, int *size;kind, size;;NULL;;0
cd6c3b4f 573
833b7ab5
YQ
574# Return the breakpoint kind for this target based on the current
575# processor state (e.g. the current instruction mode on ARM) and the
576# *PCPTR. In default, it is gdbarch->breakpoint_kind_from_pc.
ea480a30 577m;int;breakpoint_kind_from_current_state;struct regcache *regcache, CORE_ADDR *pcptr;regcache, pcptr;0;default_breakpoint_kind_from_current_state;;0
833b7ab5 578
ea480a30
SM
579M;CORE_ADDR;adjust_breakpoint_address;CORE_ADDR bpaddr;bpaddr
580m;int;memory_insert_breakpoint;struct bp_target_info *bp_tgt;bp_tgt;0;default_memory_insert_breakpoint;;0
581m;int;memory_remove_breakpoint;struct bp_target_info *bp_tgt;bp_tgt;0;default_memory_remove_breakpoint;;0
582v;CORE_ADDR;decr_pc_after_break;;;0;;;0
782263ab
AC
583
584# A function can be addressed by either it's "pointer" (possibly a
585# descriptor address) or "entry point" (first executable instruction).
586# The method "convert_from_func_ptr_addr" converting the former to the
cbf3b44a 587# latter. gdbarch_deprecated_function_start_offset is being used to implement
782263ab
AC
588# a simplified subset of that functionality - the function's address
589# corresponds to the "function pointer" and the function's start
590# corresponds to the "function entry point" - and hence is redundant.
591
ea480a30 592v;CORE_ADDR;deprecated_function_start_offset;;;0;;;0
782263ab 593
123dc839
DJ
594# Return the remote protocol register number associated with this
595# register. Normally the identity mapping.
ea480a30 596m;int;remote_register_number;int regno;regno;;default_remote_register_number;;0
123dc839 597
b2756930 598# Fetch the target specific address used to represent a load module.
ea480a30 599F;CORE_ADDR;fetch_tls_load_module_address;struct objfile *objfile;objfile
104c1213 600#
ea480a30
SM
601v;CORE_ADDR;frame_args_skip;;;0;;;0
602M;CORE_ADDR;unwind_pc;struct frame_info *next_frame;next_frame
603M;CORE_ADDR;unwind_sp;struct frame_info *next_frame;next_frame
42efa47a
AC
604# DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
605# frame-base. Enable frame-base before frame-unwind.
ea480a30 606F;int;frame_num_args;struct frame_info *frame;frame
104c1213 607#
ea480a30
SM
608M;CORE_ADDR;frame_align;CORE_ADDR address;address
609m;int;stabs_argument_has_addr;struct type *type;type;;default_stabs_argument_has_addr;;0
610v;int;frame_red_zone_size
f0d4cc9e 611#
ea480a30 612m;CORE_ADDR;convert_from_func_ptr_addr;CORE_ADDR addr, struct target_ops *targ;addr, targ;;convert_from_func_ptr_addr_identity;;0
875e1767
AC
613# On some machines there are bits in addresses which are not really
614# part of the address, but are used by the kernel, the hardware, etc.
bf6ae464 615# for special purposes. gdbarch_addr_bits_remove takes out any such bits so
875e1767
AC
616# we get a "real" address such as one would find in a symbol table.
617# This is used only for addresses of instructions, and even then I'm
618# not sure it's used in all contexts. It exists to deal with there
619# being a few stray bits in the PC which would mislead us, not as some
620# sort of generic thing to handle alignment or segmentation (it's
621# possible it should be in TARGET_READ_PC instead).
ea480a30 622m;CORE_ADDR;addr_bits_remove;CORE_ADDR addr;addr;;core_addr_identity;;0
e6590a1b
UW
623
624# FIXME/cagney/2001-01-18: This should be split in two. A target method that
625# indicates if the target needs software single step. An ISA method to
626# implement it.
627#
e6590a1b
UW
628# FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the
629# target can single step. If not, then implement single step using breakpoints.
64c4637f 630#
93f9a11f
YQ
631# Return a vector of addresses on which the software single step
632# breakpoints should be inserted. NULL means software single step is
633# not used.
634# Multiple breakpoints may be inserted for some instructions such as
635# conditional branch. However, each implementation must always evaluate
636# the condition and only put the breakpoint at the branch destination if
637# the condition is true, so that we ensure forward progress when stepping
638# past a conditional branch to self.
a0ff9e1a 639F;std::vector<CORE_ADDR>;software_single_step;struct regcache *regcache;regcache
e6590a1b 640
3352ef37
AC
641# Return non-zero if the processor is executing a delay slot and a
642# further single-step is needed before the instruction finishes.
ea480a30 643M;int;single_step_through_delay;struct frame_info *frame;frame
f6c40618 644# FIXME: cagney/2003-08-28: Need to find a better way of selecting the
b2fa5097 645# disassembler. Perhaps objdump can handle it?
39503f82 646f;int;print_insn;bfd_vma vma, struct disassemble_info *info;vma, info;;default_print_insn;;0
ea480a30 647f;CORE_ADDR;skip_trampoline_code;struct frame_info *frame, CORE_ADDR pc;frame, pc;;generic_skip_trampoline_code;;0
d50355b6
MS
648
649
cfd8ab24 650# If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
dea0c52f
MK
651# evaluates non-zero, this is the address where the debugger will place
652# a step-resume breakpoint to get us past the dynamic linker.
ea480a30 653m;CORE_ADDR;skip_solib_resolver;CORE_ADDR pc;pc;;generic_skip_solib_resolver;;0
d50355b6 654# Some systems also have trampoline code for returning from shared libs.
ea480a30 655m;int;in_solib_return_trampoline;CORE_ADDR pc, const char *name;pc, name;;generic_in_solib_return_trampoline;;0
d50355b6 656
c12260ac
CV
657# A target might have problems with watchpoints as soon as the stack
658# frame of the current function has been destroyed. This mostly happens
c9cf6e20 659# as the first action in a function's epilogue. stack_frame_destroyed_p()
c12260ac
CV
660# is defined to return a non-zero value if either the given addr is one
661# instruction after the stack destroying instruction up to the trailing
662# return instruction or if we can figure out that the stack frame has
663# already been invalidated regardless of the value of addr. Targets
664# which don't suffer from that problem could just let this functionality
665# untouched.
ea480a30 666m;int;stack_frame_destroyed_p;CORE_ADDR addr;addr;0;generic_stack_frame_destroyed_p;;0
3e29f34a
MR
667# Process an ELF symbol in the minimal symbol table in a backend-specific
668# way. Normally this hook is supposed to do nothing, however if required,
669# then this hook can be used to apply tranformations to symbols that are
670# considered special in some way. For example the MIPS backend uses it
671# to interpret \`st_other' information to mark compressed code symbols so
672# that they can be treated in the appropriate manner in the processing of
673# the main symbol table and DWARF-2 records.
ea480a30
SM
674F;void;elf_make_msymbol_special;asymbol *sym, struct minimal_symbol *msym;sym, msym
675f;void;coff_make_msymbol_special;int val, struct minimal_symbol *msym;val, msym;;default_coff_make_msymbol_special;;0
3e29f34a
MR
676# Process a symbol in the main symbol table in a backend-specific way.
677# Normally this hook is supposed to do nothing, however if required,
678# then this hook can be used to apply tranformations to symbols that
679# are considered special in some way. This is currently used by the
680# MIPS backend to make sure compressed code symbols have the ISA bit
681# set. This in turn is needed for symbol values seen in GDB to match
682# the values used at the runtime by the program itself, for function
683# and label references.
ea480a30 684f;void;make_symbol_special;struct symbol *sym, struct objfile *objfile;sym, objfile;;default_make_symbol_special;;0
3e29f34a
MR
685# Adjust the address retrieved from a DWARF-2 record other than a line
686# entry in a backend-specific way. Normally this hook is supposed to
687# return the address passed unchanged, however if that is incorrect for
688# any reason, then this hook can be used to fix the address up in the
689# required manner. This is currently used by the MIPS backend to make
690# sure addresses in FDE, range records, etc. referring to compressed
691# code have the ISA bit set, matching line information and the symbol
692# table.
ea480a30 693f;CORE_ADDR;adjust_dwarf2_addr;CORE_ADDR pc;pc;;default_adjust_dwarf2_addr;;0
3e29f34a
MR
694# Adjust the address updated by a line entry in a backend-specific way.
695# Normally this hook is supposed to return the address passed unchanged,
696# however in the case of inconsistencies in these records, this hook can
697# be used to fix them up in the required manner. This is currently used
698# by the MIPS backend to make sure all line addresses in compressed code
699# are presented with the ISA bit set, which is not always the case. This
700# in turn ensures breakpoint addresses are correctly matched against the
701# stop PC.
ea480a30
SM
702f;CORE_ADDR;adjust_dwarf2_line;CORE_ADDR addr, int rel;addr, rel;;default_adjust_dwarf2_line;;0
703v;int;cannot_step_breakpoint;;;0;0;;0
704v;int;have_nonsteppable_watchpoint;;;0;0;;0
705F;int;address_class_type_flags;int byte_size, int dwarf2_addr_class;byte_size, dwarf2_addr_class
706M;const char *;address_class_type_flags_to_name;int type_flags;type_flags
b41c5a85
JW
707# Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction.
708# FS are passed from the generic execute_cfa_program function.
ea480a30 709m;bool;execute_dwarf_cfa_vendor_op;gdb_byte op, struct dwarf2_frame_state *fs;op, fs;;default_execute_dwarf_cfa_vendor_op;;0
69f97648
SM
710
711# Return the appropriate type_flags for the supplied address class.
712# This function should return 1 if the address class was recognized and
713# type_flags was set, zero otherwise.
ea480a30 714M;int;address_class_name_to_type_flags;const char *name, int *type_flags_ptr;name, type_flags_ptr
b59ff9d5 715# Is a register in a group
ea480a30 716m;int;register_reggroup_p;int regnum, struct reggroup *reggroup;regnum, reggroup;;default_register_reggroup_p;;0
f6214256 717# Fetch the pointer to the ith function argument.
ea480a30 718F;CORE_ADDR;fetch_pointer_argument;struct frame_info *frame, int argi, struct type *type;frame, argi, type
6ce6d90f 719
5aa82d05
AA
720# Iterate over all supported register notes in a core file. For each
721# supported register note section, the iterator must call CB and pass
722# CB_DATA unchanged. If REGCACHE is not NULL, the iterator can limit
723# the supported register note sections based on the current register
724# values. Otherwise it should enumerate all supported register note
725# sections.
ea480a30 726M;void;iterate_over_regset_sections;iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache;cb, cb_data, regcache
17ea7499 727
6432734d 728# Create core file notes
ea480a30 729M;char *;make_corefile_notes;bfd *obfd, int *note_size;obfd, note_size
6432734d 730
b3ac9c77
SDJ
731# The elfcore writer hook to use to write Linux prpsinfo notes to core
732# files. Most Linux architectures use the same prpsinfo32 or
733# prpsinfo64 layouts, and so won't need to provide this hook, as we
734# call the Linux generic routines in bfd to write prpsinfo notes by
735# default.
ea480a30 736F;char *;elfcore_write_linux_prpsinfo;bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info;obfd, note_data, note_size, info
b3ac9c77 737
35c2fab7 738# Find core file memory regions
ea480a30 739M;int;find_memory_regions;find_memory_region_ftype func, void *data;func, data
35c2fab7 740
de584861 741# Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
c09f20e4
YQ
742# core file into buffer READBUF with length LEN. Return the number of bytes read
743# (zero indicates failure).
744# failed, otherwise, return the red length of READBUF.
ea480a30 745M;ULONGEST;core_xfer_shared_libraries;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len
de584861 746
356a5233
JB
747# Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared
748# libraries list from core file into buffer READBUF with length LEN.
c09f20e4 749# Return the number of bytes read (zero indicates failure).
ea480a30 750M;ULONGEST;core_xfer_shared_libraries_aix;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len
356a5233 751
c0edd9ed 752# How the core target converts a PTID from a core file to a string.
ea480a30 753M;const char *;core_pid_to_str;ptid_t ptid;ptid
28439f5e 754
4dfc5dbc 755# How the core target extracts the name of a thread from a core file.
ea480a30 756M;const char *;core_thread_name;struct thread_info *thr;thr
4dfc5dbc 757
382b69bb
JB
758# Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information
759# from core file into buffer READBUF with length LEN. Return the number
760# of bytes read (zero indicates EOF, a negative value indicates failure).
761M;LONGEST;core_xfer_siginfo;gdb_byte *readbuf, ULONGEST offset, ULONGEST len; readbuf, offset, len
762
a78c2d62 763# BFD target to use when generating a core file.
ea480a30 764V;const char *;gcore_bfd_target;;;0;0;;;pstring (gdbarch->gcore_bfd_target)
a78c2d62 765
0d5de010
DJ
766# If the elements of C++ vtables are in-place function descriptors rather
767# than normal function pointers (which may point to code or a descriptor),
768# set this to one.
ea480a30 769v;int;vtable_function_descriptors;;;0;0;;0
0d5de010
DJ
770
771# Set if the least significant bit of the delta is used instead of the least
772# significant bit of the pfn for pointers to virtual member functions.
ea480a30 773v;int;vbit_in_delta;;;0;0;;0
6d350bb5
UW
774
775# Advance PC to next instruction in order to skip a permanent breakpoint.
ea480a30 776f;void;skip_permanent_breakpoint;struct regcache *regcache;regcache;default_skip_permanent_breakpoint;default_skip_permanent_breakpoint;;0
1c772458 777
1668ae25 778# The maximum length of an instruction on this architecture in bytes.
ea480a30 779V;ULONGEST;max_insn_length;;;0;0
237fc4c9
PA
780
781# Copy the instruction at FROM to TO, and make any adjustments
782# necessary to single-step it at that address.
783#
784# REGS holds the state the thread's registers will have before
785# executing the copied instruction; the PC in REGS will refer to FROM,
786# not the copy at TO. The caller should update it to point at TO later.
787#
788# Return a pointer to data of the architecture's choice to be passed
789# to gdbarch_displaced_step_fixup. Or, return NULL to indicate that
790# the instruction's effects have been completely simulated, with the
791# resulting state written back to REGS.
792#
793# For a general explanation of displaced stepping and how GDB uses it,
794# see the comments in infrun.c.
795#
796# The TO area is only guaranteed to have space for
797# gdbarch_max_insn_length (arch) bytes, so this function must not
798# write more bytes than that to that area.
799#
800# If you do not provide this function, GDB assumes that the
801# architecture does not support displaced stepping.
802#
803# If your architecture doesn't need to adjust instructions before
804# single-stepping them, consider using simple_displaced_step_copy_insn
805# here.
7f03bd92
PA
806#
807# If the instruction cannot execute out of line, return NULL. The
808# core falls back to stepping past the instruction in-line instead in
809# that case.
ea480a30 810M;struct displaced_step_closure *;displaced_step_copy_insn;CORE_ADDR from, CORE_ADDR to, struct regcache *regs;from, to, regs
237fc4c9 811
99e40580
UW
812# Return true if GDB should use hardware single-stepping to execute
813# the displaced instruction identified by CLOSURE. If false,
814# GDB will simply restart execution at the displaced instruction
815# location, and it is up to the target to ensure GDB will receive
816# control again (e.g. by placing a software breakpoint instruction
817# into the displaced instruction buffer).
818#
819# The default implementation returns false on all targets that
820# provide a gdbarch_software_single_step routine, and true otherwise.
ea480a30 821m;int;displaced_step_hw_singlestep;struct displaced_step_closure *closure;closure;;default_displaced_step_hw_singlestep;;0
99e40580 822
237fc4c9
PA
823# Fix up the state resulting from successfully single-stepping a
824# displaced instruction, to give the result we would have gotten from
825# stepping the instruction in its original location.
826#
827# REGS is the register state resulting from single-stepping the
828# displaced instruction.
829#
830# CLOSURE is the result from the matching call to
831# gdbarch_displaced_step_copy_insn.
832#
833# If you provide gdbarch_displaced_step_copy_insn.but not this
834# function, then GDB assumes that no fixup is needed after
835# single-stepping the instruction.
836#
837# For a general explanation of displaced stepping and how GDB uses it,
838# see the comments in infrun.c.
ea480a30 839M;void;displaced_step_fixup;struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs;closure, from, to, regs;;NULL
237fc4c9 840
237fc4c9
PA
841# Return the address of an appropriate place to put displaced
842# instructions while we step over them. There need only be one such
843# place, since we're only stepping one thread over a breakpoint at a
844# time.
845#
846# For a general explanation of displaced stepping and how GDB uses it,
847# see the comments in infrun.c.
ea480a30 848m;CORE_ADDR;displaced_step_location;void;;;NULL;;(! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn)
237fc4c9 849
dde08ee1
PA
850# Relocate an instruction to execute at a different address. OLDLOC
851# is the address in the inferior memory where the instruction to
852# relocate is currently at. On input, TO points to the destination
853# where we want the instruction to be copied (and possibly adjusted)
854# to. On output, it points to one past the end of the resulting
855# instruction(s). The effect of executing the instruction at TO shall
856# be the same as if executing it at FROM. For example, call
857# instructions that implicitly push the return address on the stack
858# should be adjusted to return to the instruction after OLDLOC;
859# relative branches, and other PC-relative instructions need the
860# offset adjusted; etc.
ea480a30 861M;void;relocate_instruction;CORE_ADDR *to, CORE_ADDR from;to, from;;NULL
dde08ee1 862
1c772458 863# Refresh overlay mapped state for section OSECT.
ea480a30 864F;void;overlay_update;struct obj_section *osect;osect
4eb0ad19 865
ea480a30 866M;const struct target_desc *;core_read_description;struct target_ops *target, bfd *abfd;target, abfd
149ad273
UW
867
868# Handle special encoding of static variables in stabs debug info.
ea480a30 869F;const char *;static_transform_name;const char *name;name
203c3895 870# Set if the address in N_SO or N_FUN stabs may be zero.
ea480a30 871v;int;sofun_address_maybe_missing;;;0;0;;0
1cded358 872
0508c3ec
HZ
873# Parse the instruction at ADDR storing in the record execution log
874# the registers REGCACHE and memory ranges that will be affected when
875# the instruction executes, along with their current values.
876# Return -1 if something goes wrong, 0 otherwise.
ea480a30 877M;int;process_record;struct regcache *regcache, CORE_ADDR addr;regcache, addr
0508c3ec 878
3846b520
HZ
879# Save process state after a signal.
880# Return -1 if something goes wrong, 0 otherwise.
ea480a30 881M;int;process_record_signal;struct regcache *regcache, enum gdb_signal signal;regcache, signal
3846b520 882
22203bbf 883# Signal translation: translate inferior's signal (target's) number
86b49880
PA
884# into GDB's representation. The implementation of this method must
885# be host independent. IOW, don't rely on symbols of the NAT_FILE
886# header (the nm-*.h files), the host <signal.h> header, or similar
887# headers. This is mainly used when cross-debugging core files ---
888# "Live" targets hide the translation behind the target interface
1f8cf220 889# (target_wait, target_resume, etc.).
ea480a30 890M;enum gdb_signal;gdb_signal_from_target;int signo;signo
60c5725c 891
eb14d406
SDJ
892# Signal translation: translate the GDB's internal signal number into
893# the inferior's signal (target's) representation. The implementation
894# of this method must be host independent. IOW, don't rely on symbols
895# of the NAT_FILE header (the nm-*.h files), the host <signal.h>
896# header, or similar headers.
897# Return the target signal number if found, or -1 if the GDB internal
898# signal number is invalid.
ea480a30 899M;int;gdb_signal_to_target;enum gdb_signal signal;signal
eb14d406 900
4aa995e1
PA
901# Extra signal info inspection.
902#
903# Return a type suitable to inspect extra signal information.
ea480a30 904M;struct type *;get_siginfo_type;void;
4aa995e1 905
60c5725c 906# Record architecture-specific information from the symbol table.
ea480a30 907M;void;record_special_symbol;struct objfile *objfile, asymbol *sym;objfile, sym
50c71eaf 908
a96d9b2e
SDJ
909# Function for the 'catch syscall' feature.
910
911# Get architecture-specific system calls information from registers.
ea480a30 912M;LONGEST;get_syscall_number;ptid_t ptid;ptid
a96d9b2e 913
458c8db8 914# The filename of the XML syscall for this architecture.
ea480a30 915v;const char *;xml_syscall_file;;;0;0;;0;pstring (gdbarch->xml_syscall_file)
458c8db8
SDJ
916
917# Information about system calls from this architecture
ea480a30 918v;struct syscalls_info *;syscalls_info;;;0;0;;0;host_address_to_string (gdbarch->syscalls_info)
458c8db8 919
55aa24fb
SDJ
920# SystemTap related fields and functions.
921
05c0465e
SDJ
922# A NULL-terminated array of prefixes used to mark an integer constant
923# on the architecture's assembly.
55aa24fb
SDJ
924# For example, on x86 integer constants are written as:
925#
926# \$10 ;; integer constant 10
927#
928# in this case, this prefix would be the character \`\$\'.
ea480a30 929v;const char *const *;stap_integer_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_integer_prefixes)
55aa24fb 930
05c0465e
SDJ
931# A NULL-terminated array of suffixes used to mark an integer constant
932# on the architecture's assembly.
ea480a30 933v;const char *const *;stap_integer_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_integer_suffixes)
55aa24fb 934
05c0465e
SDJ
935# A NULL-terminated array of prefixes used to mark a register name on
936# the architecture's assembly.
55aa24fb
SDJ
937# For example, on x86 the register name is written as:
938#
939# \%eax ;; register eax
940#
941# in this case, this prefix would be the character \`\%\'.
ea480a30 942v;const char *const *;stap_register_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_register_prefixes)
55aa24fb 943
05c0465e
SDJ
944# A NULL-terminated array of suffixes used to mark a register name on
945# the architecture's assembly.
ea480a30 946v;const char *const *;stap_register_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_register_suffixes)
55aa24fb 947
05c0465e
SDJ
948# A NULL-terminated array of prefixes used to mark a register
949# indirection on the architecture's assembly.
55aa24fb
SDJ
950# For example, on x86 the register indirection is written as:
951#
952# \(\%eax\) ;; indirecting eax
953#
954# in this case, this prefix would be the charater \`\(\'.
955#
956# Please note that we use the indirection prefix also for register
957# displacement, e.g., \`4\(\%eax\)\' on x86.
ea480a30 958v;const char *const *;stap_register_indirection_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_register_indirection_prefixes)
55aa24fb 959
05c0465e
SDJ
960# A NULL-terminated array of suffixes used to mark a register
961# indirection on the architecture's assembly.
55aa24fb
SDJ
962# For example, on x86 the register indirection is written as:
963#
964# \(\%eax\) ;; indirecting eax
965#
966# in this case, this prefix would be the charater \`\)\'.
967#
968# Please note that we use the indirection suffix also for register
969# displacement, e.g., \`4\(\%eax\)\' on x86.
ea480a30 970v;const char *const *;stap_register_indirection_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_register_indirection_suffixes)
55aa24fb 971
05c0465e 972# Prefix(es) used to name a register using GDB's nomenclature.
55aa24fb
SDJ
973#
974# For example, on PPC a register is represented by a number in the assembly
975# language (e.g., \`10\' is the 10th general-purpose register). However,
976# inside GDB this same register has an \`r\' appended to its name, so the 10th
977# register would be represented as \`r10\' internally.
ea480a30 978v;const char *;stap_gdb_register_prefix;;;0;0;;0;pstring (gdbarch->stap_gdb_register_prefix)
55aa24fb
SDJ
979
980# Suffix used to name a register using GDB's nomenclature.
ea480a30 981v;const char *;stap_gdb_register_suffix;;;0;0;;0;pstring (gdbarch->stap_gdb_register_suffix)
55aa24fb
SDJ
982
983# Check if S is a single operand.
984#
985# Single operands can be:
986# \- Literal integers, e.g. \`\$10\' on x86
987# \- Register access, e.g. \`\%eax\' on x86
988# \- Register indirection, e.g. \`\(\%eax\)\' on x86
989# \- Register displacement, e.g. \`4\(\%eax\)\' on x86
990#
991# This function should check for these patterns on the string
992# and return 1 if some were found, or zero otherwise. Please try to match
993# as much info as you can from the string, i.e., if you have to match
994# something like \`\(\%\', do not match just the \`\(\'.
ea480a30 995M;int;stap_is_single_operand;const char *s;s
55aa24fb
SDJ
996
997# Function used to handle a "special case" in the parser.
998#
999# A "special case" is considered to be an unknown token, i.e., a token
1000# that the parser does not know how to parse. A good example of special
1001# case would be ARM's register displacement syntax:
1002#
1003# [R0, #4] ;; displacing R0 by 4
1004#
1005# Since the parser assumes that a register displacement is of the form:
1006#
1007# <number> <indirection_prefix> <register_name> <indirection_suffix>
1008#
1009# it means that it will not be able to recognize and parse this odd syntax.
1010# Therefore, we should add a special case function that will handle this token.
1011#
1012# This function should generate the proper expression form of the expression
1013# using GDB\'s internal expression mechanism (e.g., \`write_exp_elt_opcode\'
1014# and so on). It should also return 1 if the parsing was successful, or zero
1015# if the token was not recognized as a special token (in this case, returning
1016# zero means that the special parser is deferring the parsing to the generic
1017# parser), and should advance the buffer pointer (p->arg).
ea480a30 1018M;int;stap_parse_special_token;struct stap_parse_info *p;p
55aa24fb 1019
8b367e17
JM
1020# DTrace related functions.
1021
1022# The expression to compute the NARTGth+1 argument to a DTrace USDT probe.
1023# NARG must be >= 0.
ea480a30 1024M;void;dtrace_parse_probe_argument;struct parser_state *pstate, int narg;pstate, narg
8b367e17
JM
1025
1026# True if the given ADDR does not contain the instruction sequence
1027# corresponding to a disabled DTrace is-enabled probe.
ea480a30 1028M;int;dtrace_probe_is_enabled;CORE_ADDR addr;addr
8b367e17
JM
1029
1030# Enable a DTrace is-enabled probe at ADDR.
ea480a30 1031M;void;dtrace_enable_probe;CORE_ADDR addr;addr
8b367e17
JM
1032
1033# Disable a DTrace is-enabled probe at ADDR.
ea480a30 1034M;void;dtrace_disable_probe;CORE_ADDR addr;addr
55aa24fb 1035
50c71eaf
PA
1036# True if the list of shared libraries is one and only for all
1037# processes, as opposed to a list of shared libraries per inferior.
2567c7d9
PA
1038# This usually means that all processes, although may or may not share
1039# an address space, will see the same set of symbols at the same
1040# addresses.
ea480a30 1041v;int;has_global_solist;;;0;0;;0
2567c7d9
PA
1042
1043# On some targets, even though each inferior has its own private
1044# address space, the debug interface takes care of making breakpoints
1045# visible to all address spaces automatically. For such cases,
1046# this property should be set to true.
ea480a30 1047v;int;has_global_breakpoints;;;0;0;;0
6c95b8df
PA
1048
1049# True if inferiors share an address space (e.g., uClinux).
ea480a30 1050m;int;has_shared_address_space;void;;;default_has_shared_address_space;;0
7a697b8d
SS
1051
1052# True if a fast tracepoint can be set at an address.
ea480a30 1053m;int;fast_tracepoint_valid_at;CORE_ADDR addr, char **msg;addr, msg;;default_fast_tracepoint_valid_at;;0
75cebea9 1054
5f034a78
MK
1055# Guess register state based on tracepoint location. Used for tracepoints
1056# where no registers have been collected, but there's only one location,
1057# allowing us to guess the PC value, and perhaps some other registers.
1058# On entry, regcache has all registers marked as unavailable.
ea480a30 1059m;void;guess_tracepoint_registers;struct regcache *regcache, CORE_ADDR addr;regcache, addr;;default_guess_tracepoint_registers;;0
5f034a78 1060
f870a310 1061# Return the "auto" target charset.
ea480a30 1062f;const char *;auto_charset;void;;default_auto_charset;default_auto_charset;;0
f870a310 1063# Return the "auto" target wide charset.
ea480a30 1064f;const char *;auto_wide_charset;void;;default_auto_wide_charset;default_auto_wide_charset;;0
08105857
PA
1065
1066# If non-empty, this is a file extension that will be opened in place
1067# of the file extension reported by the shared library list.
1068#
1069# This is most useful for toolchains that use a post-linker tool,
1070# where the names of the files run on the target differ in extension
1071# compared to the names of the files GDB should load for debug info.
ea480a30 1072v;const char *;solib_symbols_extension;;;;;;;pstring (gdbarch->solib_symbols_extension)
ab38a727
PA
1073
1074# If true, the target OS has DOS-based file system semantics. That
1075# is, absolute paths include a drive name, and the backslash is
1076# considered a directory separator.
ea480a30 1077v;int;has_dos_based_file_system;;;0;0;;0
6710bf39
SS
1078
1079# Generate bytecodes to collect the return address in a frame.
1080# Since the bytecodes run on the target, possibly with GDB not even
1081# connected, the full unwinding machinery is not available, and
1082# typically this function will issue bytecodes for one or more likely
1083# places that the return address may be found.
ea480a30 1084m;void;gen_return_address;struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope;ax, value, scope;;default_gen_return_address;;0
6710bf39 1085
3030c96e 1086# Implement the "info proc" command.
ea480a30 1087M;void;info_proc;const char *args, enum info_proc_what what;args, what
3030c96e 1088
451b7c33
TT
1089# Implement the "info proc" command for core files. Noe that there
1090# are two "info_proc"-like methods on gdbarch -- one for core files,
1091# one for live targets.
ea480a30 1092M;void;core_info_proc;const char *args, enum info_proc_what what;args, what
451b7c33 1093
19630284
JB
1094# Iterate over all objfiles in the order that makes the most sense
1095# for the architecture to make global symbol searches.
1096#
1097# CB is a callback function where OBJFILE is the objfile to be searched,
1098# and CB_DATA a pointer to user-defined data (the same data that is passed
1099# when calling this gdbarch method). The iteration stops if this function
1100# returns nonzero.
1101#
1102# CB_DATA is a pointer to some user-defined data to be passed to
1103# the callback.
1104#
1105# If not NULL, CURRENT_OBJFILE corresponds to the objfile being
1106# inspected when the symbol search was requested.
ea480a30 1107m;void;iterate_over_objfiles_in_search_order;iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile;cb, cb_data, current_objfile;0;default_iterate_over_objfiles_in_search_order;;0
19630284 1108
7e35103a 1109# Ravenscar arch-dependent ops.
ea480a30 1110v;struct ravenscar_arch_ops *;ravenscar_ops;;;NULL;NULL;;0;host_address_to_string (gdbarch->ravenscar_ops)
c2170eef
MM
1111
1112# Return non-zero if the instruction at ADDR is a call; zero otherwise.
ea480a30 1113m;int;insn_is_call;CORE_ADDR addr;addr;;default_insn_is_call;;0
c2170eef
MM
1114
1115# Return non-zero if the instruction at ADDR is a return; zero otherwise.
ea480a30 1116m;int;insn_is_ret;CORE_ADDR addr;addr;;default_insn_is_ret;;0
c2170eef
MM
1117
1118# Return non-zero if the instruction at ADDR is a jump; zero otherwise.
ea480a30 1119m;int;insn_is_jump;CORE_ADDR addr;addr;;default_insn_is_jump;;0
27a48a92
MK
1120
1121# Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
1122# Return 0 if *READPTR is already at the end of the buffer.
1123# Return -1 if there is insufficient buffer for a whole entry.
1124# Return 1 if an entry was read into *TYPEP and *VALP.
ea480a30 1125M;int;auxv_parse;gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp;readptr, endptr, typep, valp
3437254d 1126
2faa3447
JB
1127# Print the description of a single auxv entry described by TYPE and VAL
1128# to FILE.
ea480a30 1129m;void;print_auxv_entry;struct ui_file *file, CORE_ADDR type, CORE_ADDR val;file, type, val;;default_print_auxv_entry;;0
2faa3447 1130
3437254d
PA
1131# Find the address range of the current inferior's vsyscall/vDSO, and
1132# write it to *RANGE. If the vsyscall's length can't be determined, a
1133# range with zero length is returned. Returns true if the vsyscall is
1134# found, false otherwise.
ea480a30 1135m;int;vsyscall_range;struct mem_range *range;range;;default_vsyscall_range;;0
f208eee0
JK
1136
1137# Allocate SIZE bytes of PROT protected page aligned memory in inferior.
1138# PROT has GDB_MMAP_PROT_* bitmask format.
1139# Throw an error if it is not possible. Returned address is always valid.
ea480a30 1140f;CORE_ADDR;infcall_mmap;CORE_ADDR size, unsigned prot;size, prot;;default_infcall_mmap;;0
f208eee0 1141
7f361056
JK
1142# Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap.
1143# Print a warning if it is not possible.
ea480a30 1144f;void;infcall_munmap;CORE_ADDR addr, CORE_ADDR size;addr, size;;default_infcall_munmap;;0
7f361056 1145
f208eee0
JK
1146# Return string (caller has to use xfree for it) with options for GCC
1147# to produce code for this target, typically "-m64", "-m32" or "-m31".
1148# These options are put before CU's DW_AT_producer compilation options so that
1149# they can override it. Method may also return NULL.
ea480a30 1150m;char *;gcc_target_options;void;;;default_gcc_target_options;;0
ac04f72b
TT
1151
1152# Return a regular expression that matches names used by this
1153# architecture in GNU configury triplets. The result is statically
1154# allocated and must not be freed. The default implementation simply
1155# returns the BFD architecture name, which is correct in nearly every
1156# case.
ea480a30 1157m;const char *;gnu_triplet_regexp;void;;;default_gnu_triplet_regexp;;0
3374165f
SM
1158
1159# Return the size in 8-bit bytes of an addressable memory unit on this
1160# architecture. This corresponds to the number of 8-bit bytes associated to
1161# each address in memory.
ea480a30 1162m;int;addressable_memory_unit_size;void;;;default_addressable_memory_unit_size;;0
3374165f 1163
65b48a81 1164# Functions for allowing a target to modify its disassembler options.
ea480a30
SM
1165v;char **;disassembler_options;;;0;0;;0;pstring_ptr (gdbarch->disassembler_options)
1166v;const disasm_options_t *;valid_disassembler_options;;;0;0;;0;host_address_to_string (gdbarch->valid_disassembler_options)
65b48a81 1167
104c1213 1168EOF
104c1213
JM
1169}
1170
0b8f9e4d
AC
1171#
1172# The .log file
1173#
1174exec > new-gdbarch.log
34620563 1175function_list | while do_read
0b8f9e4d
AC
1176do
1177 cat <<EOF
2f9b146e 1178${class} ${returntype} ${function} ($formal)
104c1213 1179EOF
3d9a5942
AC
1180 for r in ${read}
1181 do
1182 eval echo \"\ \ \ \ ${r}=\${${r}}\"
1183 done
f0d4cc9e 1184 if class_is_predicate_p && fallback_default_p
0b8f9e4d 1185 then
66d659b1 1186 echo "Error: predicate function ${function} can not have a non- multi-arch default" 1>&2
0b8f9e4d
AC
1187 kill $$
1188 exit 1
1189 fi
72e74a21 1190 if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
f0d4cc9e
AC
1191 then
1192 echo "Error: postdefault is useless when invalid_p=0" 1>&2
1193 kill $$
1194 exit 1
1195 fi
a72293e2
AC
1196 if class_is_multiarch_p
1197 then
1198 if class_is_predicate_p ; then :
1199 elif test "x${predefault}" = "x"
1200 then
2f9b146e 1201 echo "Error: pure multi-arch function ${function} must have a predefault" 1>&2
a72293e2
AC
1202 kill $$
1203 exit 1
1204 fi
1205 fi
3d9a5942 1206 echo ""
0b8f9e4d
AC
1207done
1208
1209exec 1>&2
1210compare_new gdbarch.log
1211
104c1213
JM
1212
1213copyright ()
1214{
1215cat <<EOF
c4bfde41
JK
1216/* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
1217/* vi:set ro: */
59233f88 1218
104c1213 1219/* Dynamic architecture support for GDB, the GNU debugger.
79d45cd4 1220
61baf725 1221 Copyright (C) 1998-2017 Free Software Foundation, Inc.
104c1213
JM
1222
1223 This file is part of GDB.
1224
1225 This program is free software; you can redistribute it and/or modify
1226 it under the terms of the GNU General Public License as published by
50efebf8 1227 the Free Software Foundation; either version 3 of the License, or
104c1213 1228 (at your option) any later version.
618f726f 1229
104c1213
JM
1230 This program is distributed in the hope that it will be useful,
1231 but WITHOUT ANY WARRANTY; without even the implied warranty of
1232 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1233 GNU General Public License for more details.
618f726f 1234
104c1213 1235 You should have received a copy of the GNU General Public License
50efebf8 1236 along with this program. If not, see <http://www.gnu.org/licenses/>. */
104c1213 1237
104c1213
JM
1238/* This file was created with the aid of \`\`gdbarch.sh''.
1239
52204a0b 1240 The Bourne shell script \`\`gdbarch.sh'' creates the files
104c1213
JM
1241 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
1242 against the existing \`\`gdbarch.[hc]''. Any differences found
1243 being reported.
1244
1245 If editing this file, please also run gdbarch.sh and merge any
52204a0b 1246 changes into that script. Conversely, when making sweeping changes
104c1213 1247 to this file, modifying gdbarch.sh and using its output may prove
0963b4bd 1248 easier. */
104c1213
JM
1249
1250EOF
1251}
1252
1253#
1254# The .h file
1255#
1256
1257exec > new-gdbarch.h
1258copyright
1259cat <<EOF
1260#ifndef GDBARCH_H
1261#define GDBARCH_H
1262
a0ff9e1a 1263#include <vector>
eb7a547a 1264#include "frame.h"
65b48a81 1265#include "dis-asm.h"
eb7a547a 1266
da3331ec
AC
1267struct floatformat;
1268struct ui_file;
104c1213 1269struct value;
b6af0555 1270struct objfile;
1c772458 1271struct obj_section;
a2cf933a 1272struct minimal_symbol;
049ee0e4 1273struct regcache;
b59ff9d5 1274struct reggroup;
6ce6d90f 1275struct regset;
a89aa300 1276struct disassemble_info;
e2d0e7eb 1277struct target_ops;
030f20e1 1278struct obstack;
8181d85f 1279struct bp_target_info;
424163ea 1280struct target_desc;
3e29f34a 1281struct symbol;
237fc4c9 1282struct displaced_step_closure;
a96d9b2e 1283struct syscall;
175ff332 1284struct agent_expr;
6710bf39 1285struct axs_value;
55aa24fb 1286struct stap_parse_info;
8b367e17 1287struct parser_state;
7e35103a 1288struct ravenscar_arch_ops;
b3ac9c77 1289struct elf_internal_linux_prpsinfo;
3437254d 1290struct mem_range;
458c8db8 1291struct syscalls_info;
4dfc5dbc 1292struct thread_info;
012b3a21 1293struct ui_out;
104c1213 1294
8a526fa6
PA
1295#include "regcache.h"
1296
6ecd4729
PA
1297/* The architecture associated with the inferior through the
1298 connection to the target.
1299
1300 The architecture vector provides some information that is really a
1301 property of the inferior, accessed through a particular target:
1302 ptrace operations; the layout of certain RSP packets; the solib_ops
1303 vector; etc. To differentiate architecture accesses to
1304 per-inferior/target properties from
1305 per-thread/per-frame/per-objfile properties, accesses to
1306 per-inferior/target properties should be made through this
1307 gdbarch. */
1308
1309/* This is a convenience wrapper for 'current_inferior ()->gdbarch'. */
f5656ead 1310extern struct gdbarch *target_gdbarch (void);
6ecd4729 1311
19630284
JB
1312/* Callback type for the 'iterate_over_objfiles_in_search_order'
1313 gdbarch method. */
1314
1315typedef int (iterate_over_objfiles_in_search_order_cb_ftype)
1316 (struct objfile *objfile, void *cb_data);
5aa82d05 1317
1528345d
AA
1318/* Callback type for regset section iterators. The callback usually
1319 invokes the REGSET's supply or collect method, to which it must
1320 pass a buffer with at least the given SIZE. SECT_NAME is a BFD
1321 section name, and HUMAN_NAME is used for diagnostic messages.
1322 CB_DATA should have been passed unchanged through the iterator. */
1323
5aa82d05 1324typedef void (iterate_over_regset_sections_cb)
8f0435f7
AA
1325 (const char *sect_name, int size, const struct regset *regset,
1326 const char *human_name, void *cb_data);
104c1213
JM
1327EOF
1328
1329# function typedef's
3d9a5942
AC
1330printf "\n"
1331printf "\n"
0963b4bd 1332printf "/* The following are pre-initialized by GDBARCH. */\n"
34620563 1333function_list | while do_read
104c1213 1334do
2ada493a
AC
1335 if class_is_info_p
1336 then
3d9a5942
AC
1337 printf "\n"
1338 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
0963b4bd 1339 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
2ada493a 1340 fi
104c1213
JM
1341done
1342
1343# function typedef's
3d9a5942
AC
1344printf "\n"
1345printf "\n"
0963b4bd 1346printf "/* The following are initialized by the target dependent code. */\n"
34620563 1347function_list | while do_read
104c1213 1348do
72e74a21 1349 if [ -n "${comment}" ]
34620563
AC
1350 then
1351 echo "${comment}" | sed \
1352 -e '2 s,#,/*,' \
1353 -e '3,$ s,#, ,' \
1354 -e '$ s,$, */,'
1355 fi
412d5987
AC
1356
1357 if class_is_predicate_p
2ada493a 1358 then
412d5987
AC
1359 printf "\n"
1360 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
4a5c6a1d 1361 fi
2ada493a
AC
1362 if class_is_variable_p
1363 then
3d9a5942
AC
1364 printf "\n"
1365 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
1366 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
2ada493a
AC
1367 fi
1368 if class_is_function_p
1369 then
3d9a5942 1370 printf "\n"
72e74a21 1371 if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
4a5c6a1d
AC
1372 then
1373 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
1374 elif class_is_multiarch_p
1375 then
1376 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
1377 else
1378 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
1379 fi
72e74a21 1380 if [ "x${formal}" = "xvoid" ]
104c1213 1381 then
3d9a5942 1382 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
104c1213 1383 else
3d9a5942 1384 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
104c1213 1385 fi
3d9a5942 1386 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
2ada493a 1387 fi
104c1213
JM
1388done
1389
1390# close it off
1391cat <<EOF
1392
a96d9b2e
SDJ
1393/* Definition for an unknown syscall, used basically in error-cases. */
1394#define UNKNOWN_SYSCALL (-1)
1395
104c1213
JM
1396extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1397
1398
1399/* Mechanism for co-ordinating the selection of a specific
1400 architecture.
1401
1402 GDB targets (*-tdep.c) can register an interest in a specific
1403 architecture. Other GDB components can register a need to maintain
1404 per-architecture data.
1405
1406 The mechanisms below ensures that there is only a loose connection
1407 between the set-architecture command and the various GDB
0fa6923a 1408 components. Each component can independently register their need
104c1213
JM
1409 to maintain architecture specific data with gdbarch.
1410
1411 Pragmatics:
1412
1413 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
1414 didn't scale.
1415
1416 The more traditional mega-struct containing architecture specific
1417 data for all the various GDB components was also considered. Since
0fa6923a 1418 GDB is built from a variable number of (fairly independent)
104c1213 1419 components it was determined that the global aproach was not
0963b4bd 1420 applicable. */
104c1213
JM
1421
1422
1423/* Register a new architectural family with GDB.
1424
1425 Register support for the specified ARCHITECTURE with GDB. When
1426 gdbarch determines that the specified architecture has been
1427 selected, the corresponding INIT function is called.
1428
1429 --
1430
1431 The INIT function takes two parameters: INFO which contains the
1432 information available to gdbarch about the (possibly new)
1433 architecture; ARCHES which is a list of the previously created
1434 \`\`struct gdbarch'' for this architecture.
1435
0f79675b 1436 The INFO parameter is, as far as possible, be pre-initialized with
7a107747 1437 information obtained from INFO.ABFD or the global defaults.
0f79675b
AC
1438
1439 The ARCHES parameter is a linked list (sorted most recently used)
1440 of all the previously created architures for this architecture
1441 family. The (possibly NULL) ARCHES->gdbarch can used to access
1442 values from the previously selected architecture for this
59837fe0 1443 architecture family.
104c1213
JM
1444
1445 The INIT function shall return any of: NULL - indicating that it
ec3d358c 1446 doesn't recognize the selected architecture; an existing \`\`struct
104c1213
JM
1447 gdbarch'' from the ARCHES list - indicating that the new
1448 architecture is just a synonym for an earlier architecture (see
1449 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
4b9b3959
AC
1450 - that describes the selected architecture (see gdbarch_alloc()).
1451
1452 The DUMP_TDEP function shall print out all target specific values.
1453 Care should be taken to ensure that the function works in both the
0963b4bd 1454 multi-arch and non- multi-arch cases. */
104c1213
JM
1455
1456struct gdbarch_list
1457{
1458 struct gdbarch *gdbarch;
1459 struct gdbarch_list *next;
1460};
1461
1462struct gdbarch_info
1463{
0963b4bd 1464 /* Use default: NULL (ZERO). */
104c1213
JM
1465 const struct bfd_arch_info *bfd_arch_info;
1466
428721aa 1467 /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */
94123b4f 1468 enum bfd_endian byte_order;
104c1213 1469
94123b4f 1470 enum bfd_endian byte_order_for_code;
9d4fde75 1471
0963b4bd 1472 /* Use default: NULL (ZERO). */
104c1213
JM
1473 bfd *abfd;
1474
0963b4bd 1475 /* Use default: NULL (ZERO). */
0dba2a6c
MR
1476 union
1477 {
1478 /* Architecture-specific information. The generic form for targets
1479 that have extra requirements. */
1480 struct gdbarch_tdep_info *tdep_info;
1481
1482 /* Architecture-specific target description data. Numerous targets
1483 need only this, so give them an easy way to hold it. */
1484 struct tdesc_arch_data *tdesc_data;
1485
1486 /* SPU file system ID. This is a single integer, so using the
1487 generic form would only complicate code. Other targets may
1488 reuse this member if suitable. */
1489 int *id;
1490 };
4be87837
DJ
1491
1492 /* Use default: GDB_OSABI_UNINITIALIZED (-1). */
1493 enum gdb_osabi osabi;
424163ea
DJ
1494
1495 /* Use default: NULL (ZERO). */
1496 const struct target_desc *target_desc;
104c1213
JM
1497};
1498
1499typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
4b9b3959 1500typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
104c1213 1501
4b9b3959 1502/* DEPRECATED - use gdbarch_register() */
104c1213
JM
1503extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1504
4b9b3959
AC
1505extern void gdbarch_register (enum bfd_architecture architecture,
1506 gdbarch_init_ftype *,
1507 gdbarch_dump_tdep_ftype *);
1508
104c1213 1509
b4a20239
AC
1510/* Return a freshly allocated, NULL terminated, array of the valid
1511 architecture names. Since architectures are registered during the
1512 _initialize phase this function only returns useful information
0963b4bd 1513 once initialization has been completed. */
b4a20239
AC
1514
1515extern const char **gdbarch_printable_names (void);
1516
1517
104c1213 1518/* Helper function. Search the list of ARCHES for a GDBARCH that
0963b4bd 1519 matches the information provided by INFO. */
104c1213 1520
424163ea 1521extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
104c1213
JM
1522
1523
1524/* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
424163ea 1525 basic initialization using values obtained from the INFO and TDEP
104c1213 1526 parameters. set_gdbarch_*() functions are called to complete the
0963b4bd 1527 initialization of the object. */
104c1213
JM
1528
1529extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1530
1531
4b9b3959
AC
1532/* Helper function. Free a partially-constructed \`\`struct gdbarch''.
1533 It is assumed that the caller freeds the \`\`struct
0963b4bd 1534 gdbarch_tdep''. */
4b9b3959 1535
058f20d5
JB
1536extern void gdbarch_free (struct gdbarch *);
1537
1538
aebd7893
AC
1539/* Helper function. Allocate memory from the \`\`struct gdbarch''
1540 obstack. The memory is freed when the corresponding architecture
1541 is also freed. */
1542
1543extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1544#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1545#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1546
6c214e7c
PP
1547/* Duplicate STRING, returning an equivalent string that's allocated on the
1548 obstack associated with GDBARCH. The string is freed when the corresponding
1549 architecture is also freed. */
1550
1551extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string);
aebd7893 1552
0963b4bd 1553/* Helper function. Force an update of the current architecture.
104c1213 1554
b732d07d
AC
1555 The actual architecture selected is determined by INFO, \`\`(gdb) set
1556 architecture'' et.al., the existing architecture and BFD's default
1557 architecture. INFO should be initialized to zero and then selected
1558 fields should be updated.
104c1213 1559
0963b4bd 1560 Returns non-zero if the update succeeds. */
16f33e29
AC
1561
1562extern int gdbarch_update_p (struct gdbarch_info info);
104c1213
JM
1563
1564
ebdba546
AC
1565/* Helper function. Find an architecture matching info.
1566
1567 INFO should be initialized using gdbarch_info_init, relevant fields
1568 set, and then finished using gdbarch_info_fill.
1569
1570 Returns the corresponding architecture, or NULL if no matching
59837fe0 1571 architecture was found. */
ebdba546
AC
1572
1573extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1574
1575
aff68abb 1576/* Helper function. Set the target gdbarch to "gdbarch". */
ebdba546 1577
aff68abb 1578extern void set_target_gdbarch (struct gdbarch *gdbarch);
ebdba546 1579
104c1213
JM
1580
1581/* Register per-architecture data-pointer.
1582
1583 Reserve space for a per-architecture data-pointer. An identifier
1584 for the reserved data-pointer is returned. That identifer should
95160752 1585 be saved in a local static variable.
104c1213 1586
fcc1c85c
AC
1587 Memory for the per-architecture data shall be allocated using
1588 gdbarch_obstack_zalloc. That memory will be deleted when the
1589 corresponding architecture object is deleted.
104c1213 1590
95160752
AC
1591 When a previously created architecture is re-selected, the
1592 per-architecture data-pointer for that previous architecture is
76860b5f 1593 restored. INIT() is not re-called.
104c1213
JM
1594
1595 Multiple registrarants for any architecture are allowed (and
1596 strongly encouraged). */
1597
95160752 1598struct gdbarch_data;
104c1213 1599
030f20e1
AC
1600typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1601extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1602typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1603extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1604extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1605 struct gdbarch_data *data,
1606 void *pointer);
104c1213 1607
451fbdda 1608extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
104c1213
JM
1609
1610
0fa6923a 1611/* Set the dynamic target-system-dependent parameters (architecture,
0963b4bd 1612 byte-order, ...) using information found in the BFD. */
104c1213
JM
1613
1614extern void set_gdbarch_from_file (bfd *);
1615
1616
e514a9d6
JM
1617/* Initialize the current architecture to the "first" one we find on
1618 our list. */
1619
1620extern void initialize_current_architecture (void);
1621
104c1213 1622/* gdbarch trace variable */
ccce17b0 1623extern unsigned int gdbarch_debug;
104c1213 1624
4b9b3959 1625extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
104c1213
JM
1626
1627#endif
1628EOF
1629exec 1>&2
1630#../move-if-change new-gdbarch.h gdbarch.h
59233f88 1631compare_new gdbarch.h
104c1213
JM
1632
1633
1634#
1635# C file
1636#
1637
1638exec > new-gdbarch.c
1639copyright
1640cat <<EOF
1641
1642#include "defs.h"
7355ddba 1643#include "arch-utils.h"
104c1213 1644
104c1213 1645#include "gdbcmd.h"
faaf634c 1646#include "inferior.h"
104c1213
JM
1647#include "symcat.h"
1648
f0d4cc9e 1649#include "floatformat.h"
b59ff9d5 1650#include "reggroups.h"
4be87837 1651#include "osabi.h"
aebd7893 1652#include "gdb_obstack.h"
383f836e 1653#include "observer.h"
a3ecef73 1654#include "regcache.h"
19630284 1655#include "objfiles.h"
2faa3447 1656#include "auxv.h"
95160752 1657
104c1213
JM
1658/* Static function declarations */
1659
b3cc3077 1660static void alloc_gdbarch_data (struct gdbarch *);
104c1213 1661
104c1213
JM
1662/* Non-zero if we want to trace architecture code. */
1663
1664#ifndef GDBARCH_DEBUG
1665#define GDBARCH_DEBUG 0
1666#endif
ccce17b0 1667unsigned int gdbarch_debug = GDBARCH_DEBUG;
920d2a44
AC
1668static void
1669show_gdbarch_debug (struct ui_file *file, int from_tty,
1670 struct cmd_list_element *c, const char *value)
1671{
1672 fprintf_filtered (file, _("Architecture debugging is %s.\\n"), value);
1673}
104c1213 1674
456fcf94 1675static const char *
8da61cc4 1676pformat (const struct floatformat **format)
456fcf94
AC
1677{
1678 if (format == NULL)
1679 return "(null)";
1680 else
8da61cc4
DJ
1681 /* Just print out one of them - this is only for diagnostics. */
1682 return format[0]->name;
456fcf94
AC
1683}
1684
08105857
PA
1685static const char *
1686pstring (const char *string)
1687{
1688 if (string == NULL)
1689 return "(null)";
1690 return string;
05c0465e
SDJ
1691}
1692
a121b7c1 1693static const char *
f7bb4e3a
PB
1694pstring_ptr (char **string)
1695{
1696 if (string == NULL || *string == NULL)
1697 return "(null)";
1698 return *string;
1699}
1700
05c0465e
SDJ
1701/* Helper function to print a list of strings, represented as "const
1702 char *const *". The list is printed comma-separated. */
1703
a121b7c1 1704static const char *
05c0465e
SDJ
1705pstring_list (const char *const *list)
1706{
1707 static char ret[100];
1708 const char *const *p;
1709 size_t offset = 0;
1710
1711 if (list == NULL)
1712 return "(null)";
1713
1714 ret[0] = '\0';
1715 for (p = list; *p != NULL && offset < sizeof (ret); ++p)
1716 {
1717 size_t s = xsnprintf (ret + offset, sizeof (ret) - offset, "%s, ", *p);
1718 offset += 2 + s;
1719 }
1720
1721 if (offset > 0)
1722 {
1723 gdb_assert (offset - 2 < sizeof (ret));
1724 ret[offset - 2] = '\0';
1725 }
1726
1727 return ret;
08105857
PA
1728}
1729
104c1213
JM
1730EOF
1731
1732# gdbarch open the gdbarch object
3d9a5942 1733printf "\n"
0963b4bd 1734printf "/* Maintain the struct gdbarch object. */\n"
3d9a5942
AC
1735printf "\n"
1736printf "struct gdbarch\n"
1737printf "{\n"
76860b5f
AC
1738printf " /* Has this architecture been fully initialized? */\n"
1739printf " int initialized_p;\n"
aebd7893
AC
1740printf "\n"
1741printf " /* An obstack bound to the lifetime of the architecture. */\n"
1742printf " struct obstack *obstack;\n"
1743printf "\n"
0963b4bd 1744printf " /* basic architectural information. */\n"
34620563 1745function_list | while do_read
104c1213 1746do
2ada493a
AC
1747 if class_is_info_p
1748 then
3d9a5942 1749 printf " ${returntype} ${function};\n"
2ada493a 1750 fi
104c1213 1751done
3d9a5942 1752printf "\n"
0963b4bd 1753printf " /* target specific vector. */\n"
3d9a5942
AC
1754printf " struct gdbarch_tdep *tdep;\n"
1755printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1756printf "\n"
0963b4bd 1757printf " /* per-architecture data-pointers. */\n"
95160752 1758printf " unsigned nr_data;\n"
3d9a5942
AC
1759printf " void **data;\n"
1760printf "\n"
104c1213
JM
1761cat <<EOF
1762 /* Multi-arch values.
1763
1764 When extending this structure you must:
1765
1766 Add the field below.
1767
1768 Declare set/get functions and define the corresponding
1769 macro in gdbarch.h.
1770
1771 gdbarch_alloc(): If zero/NULL is not a suitable default,
1772 initialize the new field.
1773
1774 verify_gdbarch(): Confirm that the target updated the field
1775 correctly.
1776
7e73cedf 1777 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
104c1213
JM
1778 field is dumped out
1779
104c1213
JM
1780 get_gdbarch(): Implement the set/get functions (probably using
1781 the macro's as shortcuts).
1782
1783 */
1784
1785EOF
34620563 1786function_list | while do_read
104c1213 1787do
2ada493a
AC
1788 if class_is_variable_p
1789 then
3d9a5942 1790 printf " ${returntype} ${function};\n"
2ada493a
AC
1791 elif class_is_function_p
1792 then
2f9b146e 1793 printf " gdbarch_${function}_ftype *${function};\n"
2ada493a 1794 fi
104c1213 1795done
3d9a5942 1796printf "};\n"
104c1213 1797
104c1213 1798# Create a new gdbarch struct
104c1213 1799cat <<EOF
7de2341d 1800
66b43ecb 1801/* Create a new \`\`struct gdbarch'' based on information provided by
0963b4bd 1802 \`\`struct gdbarch_info''. */
104c1213 1803EOF
3d9a5942 1804printf "\n"
104c1213
JM
1805cat <<EOF
1806struct gdbarch *
1807gdbarch_alloc (const struct gdbarch_info *info,
1808 struct gdbarch_tdep *tdep)
1809{
be7811ad 1810 struct gdbarch *gdbarch;
aebd7893
AC
1811
1812 /* Create an obstack for allocating all the per-architecture memory,
1813 then use that to allocate the architecture vector. */
70ba0933 1814 struct obstack *obstack = XNEW (struct obstack);
aebd7893 1815 obstack_init (obstack);
8d749320 1816 gdbarch = XOBNEW (obstack, struct gdbarch);
be7811ad
MD
1817 memset (gdbarch, 0, sizeof (*gdbarch));
1818 gdbarch->obstack = obstack;
85de9627 1819
be7811ad 1820 alloc_gdbarch_data (gdbarch);
85de9627 1821
be7811ad 1822 gdbarch->tdep = tdep;
104c1213 1823EOF
3d9a5942 1824printf "\n"
34620563 1825function_list | while do_read
104c1213 1826do
2ada493a
AC
1827 if class_is_info_p
1828 then
be7811ad 1829 printf " gdbarch->${function} = info->${function};\n"
2ada493a 1830 fi
104c1213 1831done
3d9a5942 1832printf "\n"
0963b4bd 1833printf " /* Force the explicit initialization of these. */\n"
34620563 1834function_list | while do_read
104c1213 1835do
2ada493a
AC
1836 if class_is_function_p || class_is_variable_p
1837 then
72e74a21 1838 if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
104c1213 1839 then
be7811ad 1840 printf " gdbarch->${function} = ${predefault};\n"
104c1213 1841 fi
2ada493a 1842 fi
104c1213
JM
1843done
1844cat <<EOF
1845 /* gdbarch_alloc() */
1846
be7811ad 1847 return gdbarch;
104c1213
JM
1848}
1849EOF
1850
058f20d5 1851# Free a gdbarch struct.
3d9a5942
AC
1852printf "\n"
1853printf "\n"
058f20d5 1854cat <<EOF
aebd7893
AC
1855/* Allocate extra space using the per-architecture obstack. */
1856
1857void *
1858gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
1859{
1860 void *data = obstack_alloc (arch->obstack, size);
05c547f6 1861
aebd7893
AC
1862 memset (data, 0, size);
1863 return data;
1864}
1865
6c214e7c
PP
1866/* See gdbarch.h. */
1867
1868char *
1869gdbarch_obstack_strdup (struct gdbarch *arch, const char *string)
1870{
1871 return obstack_strdup (arch->obstack, string);
1872}
1873
aebd7893 1874
058f20d5
JB
1875/* Free a gdbarch struct. This should never happen in normal
1876 operation --- once you've created a gdbarch, you keep it around.
1877 However, if an architecture's init function encounters an error
1878 building the structure, it may need to clean up a partially
1879 constructed gdbarch. */
4b9b3959 1880
058f20d5
JB
1881void
1882gdbarch_free (struct gdbarch *arch)
1883{
aebd7893 1884 struct obstack *obstack;
05c547f6 1885
95160752 1886 gdb_assert (arch != NULL);
aebd7893
AC
1887 gdb_assert (!arch->initialized_p);
1888 obstack = arch->obstack;
1889 obstack_free (obstack, 0); /* Includes the ARCH. */
1890 xfree (obstack);
058f20d5
JB
1891}
1892EOF
1893
104c1213 1894# verify a new architecture
104c1213 1895cat <<EOF
db446970
AC
1896
1897
1898/* Ensure that all values in a GDBARCH are reasonable. */
1899
104c1213 1900static void
be7811ad 1901verify_gdbarch (struct gdbarch *gdbarch)
104c1213 1902{
d7e74731 1903 string_file log;
05c547f6 1904
104c1213 1905 /* fundamental */
be7811ad 1906 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
d7e74731 1907 log.puts ("\n\tbyte-order");
be7811ad 1908 if (gdbarch->bfd_arch_info == NULL)
d7e74731 1909 log.puts ("\n\tbfd_arch_info");
0963b4bd 1910 /* Check those that need to be defined for the given multi-arch level. */
104c1213 1911EOF
34620563 1912function_list | while do_read
104c1213 1913do
2ada493a
AC
1914 if class_is_function_p || class_is_variable_p
1915 then
72e74a21 1916 if [ "x${invalid_p}" = "x0" ]
c0e8c252 1917 then
3d9a5942 1918 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
2ada493a
AC
1919 elif class_is_predicate_p
1920 then
0963b4bd 1921 printf " /* Skip verify of ${function}, has predicate. */\n"
f0d4cc9e 1922 # FIXME: See do_read for potential simplification
72e74a21 1923 elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
f0d4cc9e 1924 then
3d9a5942 1925 printf " if (${invalid_p})\n"
be7811ad 1926 printf " gdbarch->${function} = ${postdefault};\n"
72e74a21 1927 elif [ -n "${predefault}" -a -n "${postdefault}" ]
f0d4cc9e 1928 then
be7811ad
MD
1929 printf " if (gdbarch->${function} == ${predefault})\n"
1930 printf " gdbarch->${function} = ${postdefault};\n"
72e74a21 1931 elif [ -n "${postdefault}" ]
f0d4cc9e 1932 then
be7811ad
MD
1933 printf " if (gdbarch->${function} == 0)\n"
1934 printf " gdbarch->${function} = ${postdefault};\n"
72e74a21 1935 elif [ -n "${invalid_p}" ]
104c1213 1936 then
4d60522e 1937 printf " if (${invalid_p})\n"
d7e74731 1938 printf " log.puts (\"\\\\n\\\\t${function}\");\n"
72e74a21 1939 elif [ -n "${predefault}" ]
104c1213 1940 then
be7811ad 1941 printf " if (gdbarch->${function} == ${predefault})\n"
d7e74731 1942 printf " log.puts (\"\\\\n\\\\t${function}\");\n"
104c1213 1943 fi
2ada493a 1944 fi
104c1213
JM
1945done
1946cat <<EOF
d7e74731 1947 if (!log.empty ())
f16a1923 1948 internal_error (__FILE__, __LINE__,
85c07804 1949 _("verify_gdbarch: the following are invalid ...%s"),
d7e74731 1950 log.c_str ());
104c1213
JM
1951}
1952EOF
1953
1954# dump the structure
3d9a5942
AC
1955printf "\n"
1956printf "\n"
104c1213 1957cat <<EOF
0963b4bd 1958/* Print out the details of the current architecture. */
4b9b3959 1959
104c1213 1960void
be7811ad 1961gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
104c1213 1962{
b78960be 1963 const char *gdb_nm_file = "<not-defined>";
05c547f6 1964
b78960be
AC
1965#if defined (GDB_NM_FILE)
1966 gdb_nm_file = GDB_NM_FILE;
1967#endif
1968 fprintf_unfiltered (file,
1969 "gdbarch_dump: GDB_NM_FILE = %s\\n",
1970 gdb_nm_file);
104c1213 1971EOF
ea480a30 1972function_list | sort '-t;' -k 3 | while do_read
104c1213 1973do
1e9f55d0
AC
1974 # First the predicate
1975 if class_is_predicate_p
1976 then
7996bcec 1977 printf " fprintf_unfiltered (file,\n"
48f7351b 1978 printf " \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
be7811ad 1979 printf " gdbarch_${function}_p (gdbarch));\n"
08e45a40 1980 fi
48f7351b 1981 # Print the corresponding value.
283354d8 1982 if class_is_function_p
4b9b3959 1983 then
7996bcec 1984 printf " fprintf_unfiltered (file,\n"
30737ed9
JB
1985 printf " \"gdbarch_dump: ${function} = <%%s>\\\\n\",\n"
1986 printf " host_address_to_string (gdbarch->${function}));\n"
4b9b3959 1987 else
48f7351b 1988 # It is a variable
2f9b146e
AC
1989 case "${print}:${returntype}" in
1990 :CORE_ADDR )
0b1553bc
UW
1991 fmt="%s"
1992 print="core_addr_to_string_nz (gdbarch->${function})"
48f7351b 1993 ;;
2f9b146e 1994 :* )
48f7351b 1995 fmt="%s"
623d3eb1 1996 print="plongest (gdbarch->${function})"
48f7351b
AC
1997 ;;
1998 * )
2f9b146e 1999 fmt="%s"
48f7351b
AC
2000 ;;
2001 esac
3d9a5942 2002 printf " fprintf_unfiltered (file,\n"
48f7351b 2003 printf " \"gdbarch_dump: ${function} = %s\\\\n\",\n" "${fmt}"
3d9a5942 2004 printf " ${print});\n"
2ada493a 2005 fi
104c1213 2006done
381323f4 2007cat <<EOF
be7811ad
MD
2008 if (gdbarch->dump_tdep != NULL)
2009 gdbarch->dump_tdep (gdbarch, file);
381323f4
AC
2010}
2011EOF
104c1213
JM
2012
2013
2014# GET/SET
3d9a5942 2015printf "\n"
104c1213
JM
2016cat <<EOF
2017struct gdbarch_tdep *
2018gdbarch_tdep (struct gdbarch *gdbarch)
2019{
2020 if (gdbarch_debug >= 2)
3d9a5942 2021 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
104c1213
JM
2022 return gdbarch->tdep;
2023}
2024EOF
3d9a5942 2025printf "\n"
34620563 2026function_list | while do_read
104c1213 2027do
2ada493a
AC
2028 if class_is_predicate_p
2029 then
3d9a5942
AC
2030 printf "\n"
2031 printf "int\n"
2032 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
2033 printf "{\n"
8de9bdc4 2034 printf " gdb_assert (gdbarch != NULL);\n"
f7968451 2035 printf " return ${predicate};\n"
3d9a5942 2036 printf "}\n"
2ada493a
AC
2037 fi
2038 if class_is_function_p
2039 then
3d9a5942
AC
2040 printf "\n"
2041 printf "${returntype}\n"
72e74a21 2042 if [ "x${formal}" = "xvoid" ]
104c1213 2043 then
3d9a5942 2044 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
104c1213 2045 else
3d9a5942 2046 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
104c1213 2047 fi
3d9a5942 2048 printf "{\n"
8de9bdc4 2049 printf " gdb_assert (gdbarch != NULL);\n"
956ac328 2050 printf " gdb_assert (gdbarch->${function} != NULL);\n"
f7968451 2051 if class_is_predicate_p && test -n "${predefault}"
ae45cd16
AC
2052 then
2053 # Allow a call to a function with a predicate.
956ac328 2054 printf " /* Do not check predicate: ${predicate}, allow call. */\n"
ae45cd16 2055 fi
3d9a5942
AC
2056 printf " if (gdbarch_debug >= 2)\n"
2057 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
72e74a21 2058 if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
4a5c6a1d
AC
2059 then
2060 if class_is_multiarch_p
2061 then
2062 params="gdbarch"
2063 else
2064 params=""
2065 fi
2066 else
2067 if class_is_multiarch_p
2068 then
2069 params="gdbarch, ${actual}"
2070 else
2071 params="${actual}"
2072 fi
2073 fi
72e74a21 2074 if [ "x${returntype}" = "xvoid" ]
104c1213 2075 then
4a5c6a1d 2076 printf " gdbarch->${function} (${params});\n"
104c1213 2077 else
4a5c6a1d 2078 printf " return gdbarch->${function} (${params});\n"
104c1213 2079 fi
3d9a5942
AC
2080 printf "}\n"
2081 printf "\n"
2082 printf "void\n"
2083 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
2084 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
2085 printf "{\n"
2086 printf " gdbarch->${function} = ${function};\n"
2087 printf "}\n"
2ada493a
AC
2088 elif class_is_variable_p
2089 then
3d9a5942
AC
2090 printf "\n"
2091 printf "${returntype}\n"
2092 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
2093 printf "{\n"
8de9bdc4 2094 printf " gdb_assert (gdbarch != NULL);\n"
72e74a21 2095 if [ "x${invalid_p}" = "x0" ]
c0e8c252 2096 then
3d9a5942 2097 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
72e74a21 2098 elif [ -n "${invalid_p}" ]
104c1213 2099 then
956ac328
AC
2100 printf " /* Check variable is valid. */\n"
2101 printf " gdb_assert (!(${invalid_p}));\n"
72e74a21 2102 elif [ -n "${predefault}" ]
104c1213 2103 then
956ac328
AC
2104 printf " /* Check variable changed from pre-default. */\n"
2105 printf " gdb_assert (gdbarch->${function} != ${predefault});\n"
104c1213 2106 fi
3d9a5942
AC
2107 printf " if (gdbarch_debug >= 2)\n"
2108 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
2109 printf " return gdbarch->${function};\n"
2110 printf "}\n"
2111 printf "\n"
2112 printf "void\n"
2113 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
2114 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
2115 printf "{\n"
2116 printf " gdbarch->${function} = ${function};\n"
2117 printf "}\n"
2ada493a
AC
2118 elif class_is_info_p
2119 then
3d9a5942
AC
2120 printf "\n"
2121 printf "${returntype}\n"
2122 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
2123 printf "{\n"
8de9bdc4 2124 printf " gdb_assert (gdbarch != NULL);\n"
3d9a5942
AC
2125 printf " if (gdbarch_debug >= 2)\n"
2126 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
2127 printf " return gdbarch->${function};\n"
2128 printf "}\n"
2ada493a 2129 fi
104c1213
JM
2130done
2131
2132# All the trailing guff
2133cat <<EOF
2134
2135
f44c642f 2136/* Keep a registry of per-architecture data-pointers required by GDB
0963b4bd 2137 modules. */
104c1213
JM
2138
2139struct gdbarch_data
2140{
95160752 2141 unsigned index;
76860b5f 2142 int init_p;
030f20e1
AC
2143 gdbarch_data_pre_init_ftype *pre_init;
2144 gdbarch_data_post_init_ftype *post_init;
104c1213
JM
2145};
2146
2147struct gdbarch_data_registration
2148{
104c1213
JM
2149 struct gdbarch_data *data;
2150 struct gdbarch_data_registration *next;
2151};
2152
f44c642f 2153struct gdbarch_data_registry
104c1213 2154{
95160752 2155 unsigned nr;
104c1213
JM
2156 struct gdbarch_data_registration *registrations;
2157};
2158
f44c642f 2159struct gdbarch_data_registry gdbarch_data_registry =
104c1213
JM
2160{
2161 0, NULL,
2162};
2163
030f20e1
AC
2164static struct gdbarch_data *
2165gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
2166 gdbarch_data_post_init_ftype *post_init)
104c1213
JM
2167{
2168 struct gdbarch_data_registration **curr;
05c547f6
MS
2169
2170 /* Append the new registration. */
f44c642f 2171 for (curr = &gdbarch_data_registry.registrations;
104c1213
JM
2172 (*curr) != NULL;
2173 curr = &(*curr)->next);
70ba0933 2174 (*curr) = XNEW (struct gdbarch_data_registration);
104c1213 2175 (*curr)->next = NULL;
70ba0933 2176 (*curr)->data = XNEW (struct gdbarch_data);
f44c642f 2177 (*curr)->data->index = gdbarch_data_registry.nr++;
030f20e1
AC
2178 (*curr)->data->pre_init = pre_init;
2179 (*curr)->data->post_init = post_init;
76860b5f 2180 (*curr)->data->init_p = 1;
104c1213
JM
2181 return (*curr)->data;
2182}
2183
030f20e1
AC
2184struct gdbarch_data *
2185gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
2186{
2187 return gdbarch_data_register (pre_init, NULL);
2188}
2189
2190struct gdbarch_data *
2191gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
2192{
2193 return gdbarch_data_register (NULL, post_init);
2194}
104c1213 2195
0963b4bd 2196/* Create/delete the gdbarch data vector. */
95160752
AC
2197
2198static void
b3cc3077 2199alloc_gdbarch_data (struct gdbarch *gdbarch)
95160752 2200{
b3cc3077
JB
2201 gdb_assert (gdbarch->data == NULL);
2202 gdbarch->nr_data = gdbarch_data_registry.nr;
aebd7893 2203 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
b3cc3077 2204}
3c875b6f 2205
76860b5f 2206/* Initialize the current value of the specified per-architecture
0963b4bd 2207 data-pointer. */
b3cc3077 2208
95160752 2209void
030f20e1
AC
2210deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
2211 struct gdbarch_data *data,
2212 void *pointer)
95160752
AC
2213{
2214 gdb_assert (data->index < gdbarch->nr_data);
aebd7893 2215 gdb_assert (gdbarch->data[data->index] == NULL);
030f20e1 2216 gdb_assert (data->pre_init == NULL);
95160752
AC
2217 gdbarch->data[data->index] = pointer;
2218}
2219
104c1213 2220/* Return the current value of the specified per-architecture
0963b4bd 2221 data-pointer. */
104c1213
JM
2222
2223void *
451fbdda 2224gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
104c1213 2225{
451fbdda 2226 gdb_assert (data->index < gdbarch->nr_data);
030f20e1 2227 if (gdbarch->data[data->index] == NULL)
76860b5f 2228 {
030f20e1
AC
2229 /* The data-pointer isn't initialized, call init() to get a
2230 value. */
2231 if (data->pre_init != NULL)
2232 /* Mid architecture creation: pass just the obstack, and not
2233 the entire architecture, as that way it isn't possible for
2234 pre-init code to refer to undefined architecture
2235 fields. */
2236 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
2237 else if (gdbarch->initialized_p
2238 && data->post_init != NULL)
2239 /* Post architecture creation: pass the entire architecture
2240 (as all fields are valid), but be careful to also detect
2241 recursive references. */
2242 {
2243 gdb_assert (data->init_p);
2244 data->init_p = 0;
2245 gdbarch->data[data->index] = data->post_init (gdbarch);
2246 data->init_p = 1;
2247 }
2248 else
2249 /* The architecture initialization hasn't completed - punt -
2250 hope that the caller knows what they are doing. Once
2251 deprecated_set_gdbarch_data has been initialized, this can be
2252 changed to an internal error. */
2253 return NULL;
76860b5f
AC
2254 gdb_assert (gdbarch->data[data->index] != NULL);
2255 }
451fbdda 2256 return gdbarch->data[data->index];
104c1213
JM
2257}
2258
2259
0963b4bd 2260/* Keep a registry of the architectures known by GDB. */
104c1213 2261
4b9b3959 2262struct gdbarch_registration
104c1213
JM
2263{
2264 enum bfd_architecture bfd_architecture;
2265 gdbarch_init_ftype *init;
4b9b3959 2266 gdbarch_dump_tdep_ftype *dump_tdep;
104c1213 2267 struct gdbarch_list *arches;
4b9b3959 2268 struct gdbarch_registration *next;
104c1213
JM
2269};
2270
f44c642f 2271static struct gdbarch_registration *gdbarch_registry = NULL;
104c1213 2272
b4a20239
AC
2273static void
2274append_name (const char ***buf, int *nr, const char *name)
2275{
1dc7a623 2276 *buf = XRESIZEVEC (const char *, *buf, *nr + 1);
b4a20239
AC
2277 (*buf)[*nr] = name;
2278 *nr += 1;
2279}
2280
2281const char **
2282gdbarch_printable_names (void)
2283{
7996bcec 2284 /* Accumulate a list of names based on the registed list of
0963b4bd 2285 architectures. */
7996bcec
AC
2286 int nr_arches = 0;
2287 const char **arches = NULL;
2288 struct gdbarch_registration *rego;
05c547f6 2289
7996bcec
AC
2290 for (rego = gdbarch_registry;
2291 rego != NULL;
2292 rego = rego->next)
b4a20239 2293 {
7996bcec
AC
2294 const struct bfd_arch_info *ap;
2295 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
2296 if (ap == NULL)
2297 internal_error (__FILE__, __LINE__,
85c07804 2298 _("gdbarch_architecture_names: multi-arch unknown"));
7996bcec
AC
2299 do
2300 {
2301 append_name (&arches, &nr_arches, ap->printable_name);
2302 ap = ap->next;
2303 }
2304 while (ap != NULL);
b4a20239 2305 }
7996bcec
AC
2306 append_name (&arches, &nr_arches, NULL);
2307 return arches;
b4a20239
AC
2308}
2309
2310
104c1213 2311void
4b9b3959
AC
2312gdbarch_register (enum bfd_architecture bfd_architecture,
2313 gdbarch_init_ftype *init,
2314 gdbarch_dump_tdep_ftype *dump_tdep)
104c1213 2315{
4b9b3959 2316 struct gdbarch_registration **curr;
104c1213 2317 const struct bfd_arch_info *bfd_arch_info;
05c547f6 2318
ec3d358c 2319 /* Check that BFD recognizes this architecture */
104c1213
JM
2320 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2321 if (bfd_arch_info == NULL)
2322 {
8e65ff28 2323 internal_error (__FILE__, __LINE__,
0963b4bd
MS
2324 _("gdbarch: Attempt to register "
2325 "unknown architecture (%d)"),
8e65ff28 2326 bfd_architecture);
104c1213 2327 }
0963b4bd 2328 /* Check that we haven't seen this architecture before. */
f44c642f 2329 for (curr = &gdbarch_registry;
104c1213
JM
2330 (*curr) != NULL;
2331 curr = &(*curr)->next)
2332 {
2333 if (bfd_architecture == (*curr)->bfd_architecture)
8e65ff28 2334 internal_error (__FILE__, __LINE__,
64b9b334 2335 _("gdbarch: Duplicate registration "
0963b4bd 2336 "of architecture (%s)"),
8e65ff28 2337 bfd_arch_info->printable_name);
104c1213
JM
2338 }
2339 /* log it */
2340 if (gdbarch_debug)
30737ed9 2341 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
104c1213 2342 bfd_arch_info->printable_name,
30737ed9 2343 host_address_to_string (init));
104c1213 2344 /* Append it */
70ba0933 2345 (*curr) = XNEW (struct gdbarch_registration);
104c1213
JM
2346 (*curr)->bfd_architecture = bfd_architecture;
2347 (*curr)->init = init;
4b9b3959 2348 (*curr)->dump_tdep = dump_tdep;
104c1213
JM
2349 (*curr)->arches = NULL;
2350 (*curr)->next = NULL;
4b9b3959
AC
2351}
2352
2353void
2354register_gdbarch_init (enum bfd_architecture bfd_architecture,
2355 gdbarch_init_ftype *init)
2356{
2357 gdbarch_register (bfd_architecture, init, NULL);
104c1213 2358}
104c1213
JM
2359
2360
424163ea 2361/* Look for an architecture using gdbarch_info. */
104c1213
JM
2362
2363struct gdbarch_list *
2364gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2365 const struct gdbarch_info *info)
2366{
2367 for (; arches != NULL; arches = arches->next)
2368 {
2369 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2370 continue;
2371 if (info->byte_order != arches->gdbarch->byte_order)
2372 continue;
4be87837
DJ
2373 if (info->osabi != arches->gdbarch->osabi)
2374 continue;
424163ea
DJ
2375 if (info->target_desc != arches->gdbarch->target_desc)
2376 continue;
104c1213
JM
2377 return arches;
2378 }
2379 return NULL;
2380}
2381
2382
ebdba546 2383/* Find an architecture that matches the specified INFO. Create a new
59837fe0 2384 architecture if needed. Return that new architecture. */
104c1213 2385
59837fe0
UW
2386struct gdbarch *
2387gdbarch_find_by_info (struct gdbarch_info info)
104c1213
JM
2388{
2389 struct gdbarch *new_gdbarch;
4b9b3959 2390 struct gdbarch_registration *rego;
104c1213 2391
b732d07d 2392 /* Fill in missing parts of the INFO struct using a number of
7a107747
DJ
2393 sources: "set ..."; INFOabfd supplied; and the global
2394 defaults. */
2395 gdbarch_info_fill (&info);
4be87837 2396
0963b4bd 2397 /* Must have found some sort of architecture. */
b732d07d 2398 gdb_assert (info.bfd_arch_info != NULL);
104c1213
JM
2399
2400 if (gdbarch_debug)
2401 {
2402 fprintf_unfiltered (gdb_stdlog,
59837fe0 2403 "gdbarch_find_by_info: info.bfd_arch_info %s\n",
104c1213
JM
2404 (info.bfd_arch_info != NULL
2405 ? info.bfd_arch_info->printable_name
2406 : "(null)"));
2407 fprintf_unfiltered (gdb_stdlog,
59837fe0 2408 "gdbarch_find_by_info: info.byte_order %d (%s)\n",
104c1213 2409 info.byte_order,
d7449b42 2410 (info.byte_order == BFD_ENDIAN_BIG ? "big"
778eb05e 2411 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
104c1213 2412 : "default"));
4be87837 2413 fprintf_unfiltered (gdb_stdlog,
59837fe0 2414 "gdbarch_find_by_info: info.osabi %d (%s)\n",
4be87837 2415 info.osabi, gdbarch_osabi_name (info.osabi));
104c1213 2416 fprintf_unfiltered (gdb_stdlog,
59837fe0 2417 "gdbarch_find_by_info: info.abfd %s\n",
30737ed9 2418 host_address_to_string (info.abfd));
104c1213 2419 fprintf_unfiltered (gdb_stdlog,
59837fe0 2420 "gdbarch_find_by_info: info.tdep_info %s\n",
30737ed9 2421 host_address_to_string (info.tdep_info));
104c1213
JM
2422 }
2423
ebdba546 2424 /* Find the tdep code that knows about this architecture. */
b732d07d
AC
2425 for (rego = gdbarch_registry;
2426 rego != NULL;
2427 rego = rego->next)
2428 if (rego->bfd_architecture == info.bfd_arch_info->arch)
2429 break;
2430 if (rego == NULL)
2431 {
2432 if (gdbarch_debug)
59837fe0 2433 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
ebdba546 2434 "No matching architecture\n");
b732d07d
AC
2435 return 0;
2436 }
2437
ebdba546 2438 /* Ask the tdep code for an architecture that matches "info". */
104c1213
JM
2439 new_gdbarch = rego->init (info, rego->arches);
2440
ebdba546
AC
2441 /* Did the tdep code like it? No. Reject the change and revert to
2442 the old architecture. */
104c1213
JM
2443 if (new_gdbarch == NULL)
2444 {
2445 if (gdbarch_debug)
59837fe0 2446 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
ebdba546
AC
2447 "Target rejected architecture\n");
2448 return NULL;
104c1213
JM
2449 }
2450
ebdba546
AC
2451 /* Is this a pre-existing architecture (as determined by already
2452 being initialized)? Move it to the front of the architecture
2453 list (keeping the list sorted Most Recently Used). */
2454 if (new_gdbarch->initialized_p)
104c1213 2455 {
ebdba546 2456 struct gdbarch_list **list;
fe978cb0 2457 struct gdbarch_list *self;
104c1213 2458 if (gdbarch_debug)
59837fe0 2459 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
30737ed9
JB
2460 "Previous architecture %s (%s) selected\n",
2461 host_address_to_string (new_gdbarch),
104c1213 2462 new_gdbarch->bfd_arch_info->printable_name);
ebdba546
AC
2463 /* Find the existing arch in the list. */
2464 for (list = &rego->arches;
2465 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
2466 list = &(*list)->next);
2467 /* It had better be in the list of architectures. */
2468 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
fe978cb0
PA
2469 /* Unlink SELF. */
2470 self = (*list);
2471 (*list) = self->next;
2472 /* Insert SELF at the front. */
2473 self->next = rego->arches;
2474 rego->arches = self;
ebdba546
AC
2475 /* Return it. */
2476 return new_gdbarch;
104c1213
JM
2477 }
2478
ebdba546
AC
2479 /* It's a new architecture. */
2480 if (gdbarch_debug)
59837fe0 2481 fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
30737ed9
JB
2482 "New architecture %s (%s) selected\n",
2483 host_address_to_string (new_gdbarch),
ebdba546
AC
2484 new_gdbarch->bfd_arch_info->printable_name);
2485
2486 /* Insert the new architecture into the front of the architecture
2487 list (keep the list sorted Most Recently Used). */
0f79675b 2488 {
fe978cb0
PA
2489 struct gdbarch_list *self = XNEW (struct gdbarch_list);
2490 self->next = rego->arches;
2491 self->gdbarch = new_gdbarch;
2492 rego->arches = self;
0f79675b 2493 }
104c1213 2494
4b9b3959
AC
2495 /* Check that the newly installed architecture is valid. Plug in
2496 any post init values. */
2497 new_gdbarch->dump_tdep = rego->dump_tdep;
104c1213 2498 verify_gdbarch (new_gdbarch);
ebdba546 2499 new_gdbarch->initialized_p = 1;
104c1213 2500
4b9b3959 2501 if (gdbarch_debug)
ebdba546
AC
2502 gdbarch_dump (new_gdbarch, gdb_stdlog);
2503
2504 return new_gdbarch;
2505}
2506
e487cc15 2507/* Make the specified architecture current. */
ebdba546
AC
2508
2509void
aff68abb 2510set_target_gdbarch (struct gdbarch *new_gdbarch)
ebdba546
AC
2511{
2512 gdb_assert (new_gdbarch != NULL);
ebdba546 2513 gdb_assert (new_gdbarch->initialized_p);
6ecd4729 2514 current_inferior ()->gdbarch = new_gdbarch;
383f836e 2515 observer_notify_architecture_changed (new_gdbarch);
a3ecef73 2516 registers_changed ();
ebdba546 2517}
104c1213 2518
f5656ead 2519/* Return the current inferior's arch. */
6ecd4729
PA
2520
2521struct gdbarch *
f5656ead 2522target_gdbarch (void)
6ecd4729
PA
2523{
2524 return current_inferior ()->gdbarch;
2525}
2526
104c1213 2527void
34620563 2528_initialize_gdbarch (void)
104c1213 2529{
ccce17b0 2530 add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\\
85c07804
AC
2531Set architecture debugging."), _("\\
2532Show architecture debugging."), _("\\
2533When non-zero, architecture debugging is enabled."),
2534 NULL,
920d2a44 2535 show_gdbarch_debug,
85c07804 2536 &setdebuglist, &showdebuglist);
104c1213
JM
2537}
2538EOF
2539
2540# close things off
2541exec 1>&2
2542#../move-if-change new-gdbarch.c gdbarch.c
59233f88 2543compare_new gdbarch.c
This page took 1.770426 seconds and 4 git commands to generate.