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