Add explicit #include of "value.h".
[deliverable/binutils-gdb.git] / gdb / gdbarch.sh
CommitLineData
66b43ecb 1#!/bin/sh -u
104c1213
JM
2
3# Architecture commands for GDB, the GNU debugger.
338d7c5c 4# Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
104c1213
JM
5#
6# This file is part of GDB.
7#
8# This program is free software; you can redistribute it and/or modify
9# it under the terms of the GNU General Public License as published by
10# the Free Software Foundation; either version 2 of the License, or
11# (at your option) any later version.
12#
13# This program is distributed in the hope that it will be useful,
14# but WITHOUT ANY WARRANTY; without even the implied warranty of
15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16# GNU General Public License for more details.
17#
18# You should have received a copy of the GNU General Public License
19# along with this program; if not, write to the Free Software
20# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21
59233f88
AC
22compare_new ()
23{
24 file=$1
66b43ecb 25 if test ! -r ${file}
59233f88
AC
26 then
27 echo "${file} missing? cp new-${file} ${file}" 1>&2
28 elif diff -c ${file} new-${file}
29 then
30 echo "${file} unchanged" 1>&2
31 else
32 echo "${file} has changed? cp new-${file} ${file}" 1>&2
33 fi
34}
35
36
37# Format of the input table
0b8f9e4d 38read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
c0e8c252
AC
39
40do_read ()
41{
34620563
AC
42 comment=""
43 class=""
44 while read line
45 do
46 if test "${line}" = ""
47 then
48 continue
49 elif test "${line}" = "#" -a "${comment}" = ""
f0d4cc9e 50 then
34620563
AC
51 continue
52 elif expr "${line}" : "#" > /dev/null
f0d4cc9e 53 then
34620563
AC
54 comment="${comment}
55${line}"
f0d4cc9e 56 else
3d9a5942
AC
57
58 # The semantics of IFS varies between different SH's. Some
59 # treat ``::' as three fields while some treat it as just too.
60 # Work around this by eliminating ``::'' ....
61 line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
62
63 OFS="${IFS}" ; IFS="[:]"
34620563
AC
64 eval read ${read} <<EOF
65${line}
66EOF
67 IFS="${OFS}"
68
3d9a5942
AC
69 # .... and then going back through each field and strip out those
70 # that ended up with just that space character.
71 for r in ${read}
72 do
73 if eval test \"\${${r}}\" = \"\ \"
74 then
75 eval ${r}=""
76 fi
77 done
78
34620563
AC
79 test "${staticdefault}" || staticdefault=0
80 # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
81 # multi-arch defaults.
82 # test "${predefault}" || predefault=0
83 test "${fmt}" || fmt="%ld"
84 test "${print}" || print="(long) ${macro}"
85 case "${invalid_p}" in
86 0 ) valid_p=1 ;;
87 "" )
72e74a21 88 if [ -n "${predefault}" ]
34620563
AC
89 then
90 #invalid_p="gdbarch->${function} == ${predefault}"
91 valid_p="gdbarch->${function} != ${predefault}"
92 else
93 #invalid_p="gdbarch->${function} == 0"
94 valid_p="gdbarch->${function} != 0"
95 fi
96 ;;
97 * ) valid_p="!(${invalid_p})"
98 esac
99
100 # PREDEFAULT is a valid fallback definition of MEMBER when
101 # multi-arch is not enabled. This ensures that the
102 # default value, when multi-arch is the same as the
103 # default value when not multi-arch. POSTDEFAULT is
104 # always a valid definition of MEMBER as this again
105 # ensures consistency.
106
72e74a21 107 if [ -n "${postdefault}" ]
34620563
AC
108 then
109 fallbackdefault="${postdefault}"
72e74a21 110 elif [ -n "${predefault}" ]
34620563
AC
111 then
112 fallbackdefault="${predefault}"
113 else
73d3c16e 114 fallbackdefault="0"
34620563
AC
115 fi
116
117 #NOT YET: See gdbarch.log for basic verification of
118 # database
119
120 break
f0d4cc9e 121 fi
34620563 122 done
72e74a21 123 if [ -n "${class}" ]
34620563
AC
124 then
125 true
c0e8c252
AC
126 else
127 false
128 fi
129}
130
104c1213 131
f0d4cc9e
AC
132fallback_default_p ()
133{
72e74a21
JB
134 [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
135 || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
f0d4cc9e
AC
136}
137
138class_is_variable_p ()
139{
4a5c6a1d
AC
140 case "${class}" in
141 *v* | *V* ) true ;;
142 * ) false ;;
143 esac
f0d4cc9e
AC
144}
145
146class_is_function_p ()
147{
4a5c6a1d
AC
148 case "${class}" in
149 *f* | *F* | *m* | *M* ) true ;;
150 * ) false ;;
151 esac
152}
153
154class_is_multiarch_p ()
155{
156 case "${class}" in
157 *m* | *M* ) true ;;
158 * ) false ;;
159 esac
f0d4cc9e
AC
160}
161
162class_is_predicate_p ()
163{
4a5c6a1d
AC
164 case "${class}" in
165 *F* | *V* | *M* ) true ;;
166 * ) false ;;
167 esac
f0d4cc9e
AC
168}
169
170class_is_info_p ()
171{
4a5c6a1d
AC
172 case "${class}" in
173 *i* ) true ;;
174 * ) false ;;
175 esac
f0d4cc9e
AC
176}
177
178
cff3e48b
JM
179# dump out/verify the doco
180for field in ${read}
181do
182 case ${field} in
183
184 class ) : ;;
c4093a6a 185
c0e8c252
AC
186 # # -> line disable
187 # f -> function
188 # hiding a function
2ada493a
AC
189 # F -> function + predicate
190 # hiding a function + predicate to test function validity
c0e8c252
AC
191 # v -> variable
192 # hiding a variable
2ada493a
AC
193 # V -> variable + predicate
194 # hiding a variable + predicate to test variables validity
c0e8c252
AC
195 # i -> set from info
196 # hiding something from the ``struct info'' object
4a5c6a1d
AC
197 # m -> multi-arch function
198 # hiding a multi-arch function (parameterised with the architecture)
199 # M -> multi-arch function + predicate
200 # hiding a multi-arch function + predicate to test function validity
cff3e48b
JM
201
202 level ) : ;;
203
c0e8c252
AC
204 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
205 # LEVEL is a predicate on checking that a given method is
206 # initialized (using INVALID_P).
cff3e48b
JM
207
208 macro ) : ;;
209
c0e8c252 210 # The name of the MACRO that this method is to be accessed by.
cff3e48b
JM
211
212 returntype ) : ;;
213
c0e8c252 214 # For functions, the return type; for variables, the data type
cff3e48b
JM
215
216 function ) : ;;
217
c0e8c252
AC
218 # For functions, the member function name; for variables, the
219 # variable name. Member function names are always prefixed with
220 # ``gdbarch_'' for name-space purity.
cff3e48b
JM
221
222 formal ) : ;;
223
c0e8c252
AC
224 # The formal argument list. It is assumed that the formal
225 # argument list includes the actual name of each list element.
226 # A function with no arguments shall have ``void'' as the
227 # formal argument list.
cff3e48b
JM
228
229 actual ) : ;;
230
c0e8c252
AC
231 # The list of actual arguments. The arguments specified shall
232 # match the FORMAL list given above. Functions with out
233 # arguments leave this blank.
cff3e48b
JM
234
235 attrib ) : ;;
236
c0e8c252
AC
237 # Any GCC attributes that should be attached to the function
238 # declaration. At present this field is unused.
cff3e48b 239
0b8f9e4d 240 staticdefault ) : ;;
c0e8c252
AC
241
242 # To help with the GDB startup a static gdbarch object is
0b8f9e4d
AC
243 # created. STATICDEFAULT is the value to insert into that
244 # static gdbarch object. Since this a static object only
245 # simple expressions can be used.
cff3e48b 246
0b8f9e4d 247 # If STATICDEFAULT is empty, zero is used.
c0e8c252 248
0b8f9e4d 249 predefault ) : ;;
cff3e48b 250
10312cc4
AC
251 # An initial value to assign to MEMBER of the freshly
252 # malloc()ed gdbarch object. After initialization, the
253 # freshly malloc()ed object is passed to the target
254 # architecture code for further updates.
cff3e48b 255
0b8f9e4d
AC
256 # If PREDEFAULT is empty, zero is used.
257
10312cc4
AC
258 # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
259 # INVALID_P are specified, PREDEFAULT will be used as the
260 # default for the non- multi-arch target.
261
262 # A zero PREDEFAULT function will force the fallback to call
263 # internal_error().
f0d4cc9e
AC
264
265 # Variable declarations can refer to ``gdbarch'' which will
266 # contain the current architecture. Care should be taken.
0b8f9e4d
AC
267
268 postdefault ) : ;;
269
270 # A value to assign to MEMBER of the new gdbarch object should
10312cc4
AC
271 # the target architecture code fail to change the PREDEFAULT
272 # value.
0b8f9e4d
AC
273
274 # If POSTDEFAULT is empty, no post update is performed.
275
276 # If both INVALID_P and POSTDEFAULT are non-empty then
277 # INVALID_P will be used to determine if MEMBER should be
278 # changed to POSTDEFAULT.
279
10312cc4
AC
280 # If a non-empty POSTDEFAULT and a zero INVALID_P are
281 # specified, POSTDEFAULT will be used as the default for the
282 # non- multi-arch target (regardless of the value of
283 # PREDEFAULT).
284
f0d4cc9e
AC
285 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
286
287 # Variable declarations can refer to ``gdbarch'' which will
288 # contain the current architecture. Care should be taken.
cff3e48b 289
c4093a6a 290 invalid_p ) : ;;
cff3e48b 291
0b8f9e4d 292 # A predicate equation that validates MEMBER. Non-zero is
c0e8c252 293 # returned if the code creating the new architecture failed to
0b8f9e4d
AC
294 # initialize MEMBER or the initialized the member is invalid.
295 # If POSTDEFAULT is non-empty then MEMBER will be updated to
296 # that value. If POSTDEFAULT is empty then internal_error()
297 # is called.
298
299 # If INVALID_P is empty, a check that MEMBER is no longer
300 # equal to PREDEFAULT is used.
301
f0d4cc9e
AC
302 # The expression ``0'' disables the INVALID_P check making
303 # PREDEFAULT a legitimate value.
0b8f9e4d
AC
304
305 # See also PREDEFAULT and POSTDEFAULT.
cff3e48b
JM
306
307 fmt ) : ;;
308
c0e8c252
AC
309 # printf style format string that can be used to print out the
310 # MEMBER. Sometimes "%s" is useful. For functions, this is
311 # ignored and the function address is printed.
312
0b8f9e4d 313 # If FMT is empty, ``%ld'' is used.
cff3e48b
JM
314
315 print ) : ;;
316
c0e8c252
AC
317 # An optional equation that casts MEMBER to a value suitable
318 # for formatting by FMT.
319
0b8f9e4d 320 # If PRINT is empty, ``(long)'' is used.
cff3e48b
JM
321
322 print_p ) : ;;
323
c0e8c252
AC
324 # An optional indicator for any predicte to wrap around the
325 # print member code.
326
4b9b3959 327 # () -> Call a custom function to do the dump.
c0e8c252
AC
328 # exp -> Wrap print up in ``if (${print_p}) ...
329 # ``'' -> No predicate
cff3e48b 330
0b8f9e4d
AC
331 # If PRINT_P is empty, ``1'' is always used.
332
cff3e48b
JM
333 description ) : ;;
334
0b8f9e4d 335 # Currently unused.
cff3e48b
JM
336
337 *) exit 1;;
338 esac
339done
340
cff3e48b 341
104c1213
JM
342function_list ()
343{
cff3e48b 344 # See below (DOCO) for description of each field
34620563 345 cat <<EOF
0b8f9e4d 346i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
104c1213
JM
347#
348i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
66b43ecb
AC
349# Number of bits in a char or unsigned char for the target machine.
350# Just like CHAR_BIT in <limits.h> but describes the target machine.
351# v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
352#
353# Number of bits in a short or unsigned short for the target machine.
354v::TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
355# Number of bits in an int or unsigned int for the target machine.
356v::TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
357# Number of bits in a long or unsigned long for the target machine.
358v::TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
359# Number of bits in a long long or unsigned long long for the target
360# machine.
361v::TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
362# Number of bits in a float for the target machine.
363v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
364# Number of bits in a double for the target machine.
365v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
366# Number of bits in a long double for the target machine.
367v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0
52204a0b
DT
368# For most targets, a pointer on the target and its representation as an
369# address in GDB have the same size and "look the same". For such a
370# target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
371# / addr_bit will be set from it.
372#
373# If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
374# also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
375#
376# ptr_bit is the size of a pointer on the target
66b43ecb 377v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
52204a0b
DT
378# addr_bit is the size of a target address as represented in gdb
379v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
66b43ecb
AC
380# Number of bits in a BFD_VMA for the target object file format.
381v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
104c1213 382#
be8dfb87 383v::IEEE_FLOAT:int:ieee_float::::0:0::0:::
104c1213 384#
39f77062
KB
385f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
386f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
be8dfb87
AC
387f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
388f::TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:generic_target_write_fp::0
389f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
390f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
39d4ef09
AC
391# Function for getting target's idea of a frame pointer. FIXME: GDB's
392# whole scheme for dealing with "frames" and "frame pointers" needs a
393# serious shakedown.
394f::TARGET_VIRTUAL_FRAME_POINTER: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 395#
61a0eb5b
AC
396M:::void:register_read:int regnum, char *buf:regnum, buf:
397M:::void:register_write:int regnum, char *buf:regnum, buf:
398#
104c1213 399v:2:NUM_REGS:int:num_regs::::0:-1
0aba1244
EZ
400# This macro gives the number of pseudo-registers that live in the
401# register namespace but do not get fetched or stored on the target.
3d9a5942
AC
402# These pseudo-registers may be aliases for other registers,
403# combinations of other registers, or they may be computed by GDB.
0aba1244 404v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
104c1213
JM
405v:2:SP_REGNUM:int:sp_regnum::::0:-1
406v:2:FP_REGNUM:int:fp_regnum::::0:-1
407v:2:PC_REGNUM:int:pc_regnum::::0:-1
0b8f9e4d
AC
408v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
409v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
410v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
88c72b7d
AC
411# Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
412f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
413# Provide a default mapping from a ecoff register number to a gdb REGNUM.
414f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
415# Provide a default mapping from a DWARF register number to a gdb REGNUM.
416f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
417# Convert from an sdb register number to an internal gdb register number.
418# This should be defined in tm.h, if REGISTER_NAMES is not set up
419# to map one to one onto the sdb register numbers.
420f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
421f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
0b8f9e4d 422f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
104c1213
JM
423v:2:REGISTER_SIZE:int:register_size::::0:-1
424v:2:REGISTER_BYTES:int:register_bytes::::0:-1
425f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
426f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
427v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
428f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
429v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
430f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
666e11c5 431f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
7c7651b2
AC
432# MAP a GDB RAW register number onto a simulator register number. See
433# also include/...-sim.h.
434f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
2649061d 435F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
01fb7433
AC
436f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
437f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
104c1213
JM
438#
439v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
440v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
0b8f9e4d
AC
441f:2:CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void:::0:0::gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0
442v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
83e6b173 443v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1:0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
104c1213 444v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
0b8f9e4d 445v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
104c1213
JM
446f:2:PC_IN_CALL_DUMMY:int:pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::0:0
447v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
0b8f9e4d
AC
448v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
449v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
450v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
451v:2:CALL_DUMMY_STACK_ADJUST:int:call_dummy_stack_adjust::::0:::gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0:0x%08lx::CALL_DUMMY_STACK_ADJUST_P
452f:2:FIX_CALL_DUMMY:void:fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p:::0
10312cc4 453f:2:INIT_FRAME_PC_FIRST:void:init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_noop::0
7824d2f2 454f:2:INIT_FRAME_PC:void:init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_default::0
104c1213 455#
f0d4cc9e
AC
456v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
457v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
0b8f9e4d 458f:2:COERCE_FLOAT_TO_DOUBLE:int:coerce_float_to_double:struct type *formal, struct type *actual:formal, actual:::default_coerce_float_to_double::0
104c1213
JM
459f:1:GET_SAVED_REGISTER:void:get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval::generic_get_saved_register:0
460#
0b8f9e4d
AC
461f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
462f:2:REGISTER_CONVERT_TO_VIRTUAL:void:register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to:::0::0
463f:2:REGISTER_CONVERT_TO_RAW:void:register_convert_to_raw:struct type *type, int regnum, char *from, char *to:type, regnum, from, to:::0::0
34620563
AC
464# This function is called when the value of a pseudo-register needs to
465# be updated. Typically it will be defined on a per-architecture
466# basis.
7f1b2585 467f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
34620563
AC
468# This function is called when the value of a pseudo-register needs to
469# be set or stored. Typically it will be defined on a
470# per-architecture basis.
7f1b2585 471f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
104c1213 472#
ac2e2ef7
AC
473f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
474f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, void *buf, CORE_ADDR addr:type, buf, addr:::unsigned_address_to_pointer::0
fc0c74b1 475F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
4478b372 476#
0b8f9e4d 477f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
104c1213
JM
478f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
479f:1:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr::0:0
c0e8c252
AC
480f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
481f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
482f:2:POP_FRAME:void:pop_frame:void:-:::0
104c1213 483#
c0e8c252
AC
484f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
485f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
d6dd581e 486F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
c0e8c252 487f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
104c1213
JM
488#
489f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
c0e8c252 490f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
104c1213
JM
491#
492f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
0b8f9e4d 493f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
104c1213 494f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
0b8f9e4d
AC
495f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
496f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
497f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
104c1213 498v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
e02bc4cc 499f::PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
104c1213
JM
500v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
501#
0b8f9e4d 502f:2:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
104c1213
JM
503#
504v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
0b8f9e4d 505f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
104c1213
JM
506f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
507f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
508f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
509f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
510f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
511f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
512f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
513#
2ada493a 514F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
0a49d05e 515v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
d03e67c9 516F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
d1e3cf49 517F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
58d5518e 518v:2:PARM_BOUNDARY:int:parm_boundary
f0d4cc9e
AC
519#
520v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
521v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
522v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
875e1767
AC
523f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0
524# On some machines there are bits in addresses which are not really
525# part of the address, but are used by the kernel, the hardware, etc.
526# for special purposes. ADDR_BITS_REMOVE takes out any such bits so
527# we get a "real" address such as one would find in a symbol table.
528# This is used only for addresses of instructions, and even then I'm
529# not sure it's used in all contexts. It exists to deal with there
530# being a few stray bits in the PC which would mislead us, not as some
531# sort of generic thing to handle alignment or segmentation (it's
532# possible it should be in TARGET_READ_PC instead).
533f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
64c4637f
AC
534# FIXME/cagney/2001-01-18: This should be split in two. A target method that indicates if
535# the target needs software single step. An ISA method to implement it.
536#
537# FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
538# using the breakpoint system instead of blatting memory directly (as with rs6000).
539#
540# FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the target can
541# single step. If not, then implement single step using breakpoints.
542F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
2bf0cb65 543f:2:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, disassemble_info *info:vma, info:::legacy_print_insn::0
bdcd319a 544f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
104c1213 545EOF
104c1213
JM
546}
547
0b8f9e4d
AC
548#
549# The .log file
550#
551exec > new-gdbarch.log
34620563 552function_list | while do_read
0b8f9e4d
AC
553do
554 cat <<EOF
104c1213
JM
555${class} ${macro}(${actual})
556 ${returntype} ${function} ($formal)${attrib}
104c1213 557EOF
3d9a5942
AC
558 for r in ${read}
559 do
560 eval echo \"\ \ \ \ ${r}=\${${r}}\"
561 done
562# #fallbackdefault=${fallbackdefault}
563# #valid_p=${valid_p}
564#EOF
f0d4cc9e 565 if class_is_predicate_p && fallback_default_p
0b8f9e4d 566 then
66b43ecb 567 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
0b8f9e4d
AC
568 kill $$
569 exit 1
570 fi
72e74a21 571 if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
f0d4cc9e
AC
572 then
573 echo "Error: postdefault is useless when invalid_p=0" 1>&2
574 kill $$
575 exit 1
576 fi
3d9a5942 577 echo ""
0b8f9e4d
AC
578done
579
580exec 1>&2
581compare_new gdbarch.log
582
104c1213
JM
583
584copyright ()
585{
586cat <<EOF
59233f88
AC
587/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
588
104c1213 589/* Dynamic architecture support for GDB, the GNU debugger.
338d7c5c 590 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
104c1213
JM
591
592 This file is part of GDB.
593
594 This program is free software; you can redistribute it and/or modify
595 it under the terms of the GNU General Public License as published by
596 the Free Software Foundation; either version 2 of the License, or
597 (at your option) any later version.
598
599 This program is distributed in the hope that it will be useful,
600 but WITHOUT ANY WARRANTY; without even the implied warranty of
601 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
602 GNU General Public License for more details.
603
604 You should have received a copy of the GNU General Public License
605 along with this program; if not, write to the Free Software
606 Foundation, Inc., 59 Temple Place - Suite 330,
607 Boston, MA 02111-1307, USA. */
608
104c1213
JM
609/* This file was created with the aid of \`\`gdbarch.sh''.
610
52204a0b 611 The Bourne shell script \`\`gdbarch.sh'' creates the files
104c1213
JM
612 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
613 against the existing \`\`gdbarch.[hc]''. Any differences found
614 being reported.
615
616 If editing this file, please also run gdbarch.sh and merge any
52204a0b 617 changes into that script. Conversely, when making sweeping changes
104c1213
JM
618 to this file, modifying gdbarch.sh and using its output may prove
619 easier. */
620
621EOF
622}
623
624#
625# The .h file
626#
627
628exec > new-gdbarch.h
629copyright
630cat <<EOF
631#ifndef GDBARCH_H
632#define GDBARCH_H
633
2bf0cb65 634#include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
fd0407d6
AC
635#if !GDB_MULTI_ARCH
636#include "value.h" /* For default_coerce_float_to_double which is referenced by a macro. */
637#endif
2bf0cb65 638
104c1213
JM
639struct frame_info;
640struct value;
641
642
104c1213
JM
643extern struct gdbarch *current_gdbarch;
644
645
104c1213
JM
646/* If any of the following are defined, the target wasn't correctly
647 converted. */
648
104c1213
JM
649#if GDB_MULTI_ARCH
650#if defined (EXTRA_FRAME_INFO)
651#error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
652#endif
653#endif
654
655#if GDB_MULTI_ARCH
656#if defined (FRAME_FIND_SAVED_REGS)
657#error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
658#endif
659#endif
83905903
AC
660
661#if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
662#error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
663#endif
104c1213
JM
664EOF
665
666# function typedef's
3d9a5942
AC
667printf "\n"
668printf "\n"
669printf "/* The following are pre-initialized by GDBARCH. */\n"
34620563 670function_list | while do_read
104c1213 671do
2ada493a
AC
672 if class_is_info_p
673 then
3d9a5942
AC
674 printf "\n"
675 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
676 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
83905903
AC
677 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
678 printf "#error \"Non multi-arch definition of ${macro}\"\n"
679 printf "#endif\n"
3d9a5942
AC
680 printf "#if GDB_MULTI_ARCH\n"
681 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
682 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
683 printf "#endif\n"
684 printf "#endif\n"
2ada493a 685 fi
104c1213
JM
686done
687
688# function typedef's
3d9a5942
AC
689printf "\n"
690printf "\n"
691printf "/* The following are initialized by the target dependent code. */\n"
34620563 692function_list | while do_read
104c1213 693do
72e74a21 694 if [ -n "${comment}" ]
34620563
AC
695 then
696 echo "${comment}" | sed \
697 -e '2 s,#,/*,' \
698 -e '3,$ s,#, ,' \
699 -e '$ s,$, */,'
700 fi
b77be6cf 701 if class_is_multiarch_p
2ada493a 702 then
b77be6cf
AC
703 if class_is_predicate_p
704 then
705 printf "\n"
706 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
707 fi
708 else
709 if class_is_predicate_p
710 then
711 printf "\n"
712 printf "#if defined (${macro})\n"
713 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
714 #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
eee30e78 715 printf "#if !defined (${macro}_P)\n"
b77be6cf
AC
716 printf "#define ${macro}_P() (1)\n"
717 printf "#endif\n"
eee30e78 718 printf "#endif\n"
b77be6cf
AC
719 printf "\n"
720 printf "/* Default predicate for non- multi-arch targets. */\n"
721 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
722 printf "#define ${macro}_P() (0)\n"
723 printf "#endif\n"
724 printf "\n"
725 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
83905903
AC
726 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro}_P)\n"
727 printf "#error \"Non multi-arch definition of ${macro}\"\n"
728 printf "#endif\n"
b77be6cf
AC
729 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
730 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
731 printf "#endif\n"
732 fi
4a5c6a1d 733 fi
2ada493a
AC
734 if class_is_variable_p
735 then
f0d4cc9e 736 if fallback_default_p || class_is_predicate_p
33489c5b 737 then
3d9a5942
AC
738 printf "\n"
739 printf "/* Default (value) for non- multi-arch platforms. */\n"
740 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
f0d4cc9e
AC
741 echo "#define ${macro} (${fallbackdefault})" \
742 | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
3d9a5942 743 printf "#endif\n"
33489c5b 744 fi
3d9a5942
AC
745 printf "\n"
746 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
747 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
83905903
AC
748 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
749 printf "#error \"Non multi-arch definition of ${macro}\"\n"
750 printf "#endif\n"
3d9a5942
AC
751 printf "#if GDB_MULTI_ARCH\n"
752 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
753 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
754 printf "#endif\n"
755 printf "#endif\n"
2ada493a
AC
756 fi
757 if class_is_function_p
758 then
b77be6cf
AC
759 if class_is_multiarch_p ; then :
760 elif fallback_default_p || class_is_predicate_p
33489c5b 761 then
3d9a5942
AC
762 printf "\n"
763 printf "/* Default (function) for non- multi-arch platforms. */\n"
764 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
72e74a21 765 if [ "x${fallbackdefault}" = "x0" ]
33489c5b 766 then
8e65ff28 767 printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
33489c5b 768 else
f0d4cc9e
AC
769 # FIXME: Should be passing current_gdbarch through!
770 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
771 | sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
33489c5b 772 fi
3d9a5942 773 printf "#endif\n"
33489c5b 774 fi
3d9a5942 775 printf "\n"
72e74a21 776 if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
4a5c6a1d
AC
777 then
778 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
779 elif class_is_multiarch_p
780 then
781 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
782 else
783 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
784 fi
72e74a21 785 if [ "x${formal}" = "xvoid" ]
104c1213 786 then
3d9a5942 787 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
104c1213 788 else
3d9a5942 789 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
104c1213 790 fi
3d9a5942 791 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
b77be6cf
AC
792 if class_is_multiarch_p ; then :
793 else
83905903
AC
794 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
795 printf "#error \"Non multi-arch definition of ${macro}\"\n"
796 printf "#endif\n"
4a5c6a1d
AC
797 printf "#if GDB_MULTI_ARCH\n"
798 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
72e74a21 799 if [ "x${actual}" = "x" ]
4a5c6a1d
AC
800 then
801 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
72e74a21 802 elif [ "x${actual}" = "x-" ]
4a5c6a1d
AC
803 then
804 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
805 else
806 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
807 fi
808 printf "#endif\n"
809 printf "#endif\n"
104c1213 810 fi
2ada493a 811 fi
104c1213
JM
812done
813
814# close it off
815cat <<EOF
816
817extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
818
819
820/* Mechanism for co-ordinating the selection of a specific
821 architecture.
822
823 GDB targets (*-tdep.c) can register an interest in a specific
824 architecture. Other GDB components can register a need to maintain
825 per-architecture data.
826
827 The mechanisms below ensures that there is only a loose connection
828 between the set-architecture command and the various GDB
0fa6923a 829 components. Each component can independently register their need
104c1213
JM
830 to maintain architecture specific data with gdbarch.
831
832 Pragmatics:
833
834 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
835 didn't scale.
836
837 The more traditional mega-struct containing architecture specific
838 data for all the various GDB components was also considered. Since
0fa6923a 839 GDB is built from a variable number of (fairly independent)
104c1213
JM
840 components it was determined that the global aproach was not
841 applicable. */
842
843
844/* Register a new architectural family with GDB.
845
846 Register support for the specified ARCHITECTURE with GDB. When
847 gdbarch determines that the specified architecture has been
848 selected, the corresponding INIT function is called.
849
850 --
851
852 The INIT function takes two parameters: INFO which contains the
853 information available to gdbarch about the (possibly new)
854 architecture; ARCHES which is a list of the previously created
855 \`\`struct gdbarch'' for this architecture.
856
857 The INIT function parameter INFO shall, as far as possible, be
858 pre-initialized with information obtained from INFO.ABFD or
859 previously selected architecture (if similar). INIT shall ensure
860 that the INFO.BYTE_ORDER is non-zero.
861
862 The INIT function shall return any of: NULL - indicating that it
ec3d358c 863 doesn't recognize the selected architecture; an existing \`\`struct
104c1213
JM
864 gdbarch'' from the ARCHES list - indicating that the new
865 architecture is just a synonym for an earlier architecture (see
866 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
4b9b3959
AC
867 - that describes the selected architecture (see gdbarch_alloc()).
868
869 The DUMP_TDEP function shall print out all target specific values.
870 Care should be taken to ensure that the function works in both the
871 multi-arch and non- multi-arch cases. */
104c1213
JM
872
873struct gdbarch_list
874{
875 struct gdbarch *gdbarch;
876 struct gdbarch_list *next;
877};
878
879struct gdbarch_info
880{
104c1213
JM
881 /* Use default: NULL (ZERO). */
882 const struct bfd_arch_info *bfd_arch_info;
883
884 /* Use default: 0 (ZERO). */
885 int byte_order;
886
887 /* Use default: NULL (ZERO). */
888 bfd *abfd;
889
890 /* Use default: NULL (ZERO). */
891 struct gdbarch_tdep_info *tdep_info;
892};
893
894typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
4b9b3959 895typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
104c1213 896
4b9b3959 897/* DEPRECATED - use gdbarch_register() */
104c1213
JM
898extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
899
4b9b3959
AC
900extern void gdbarch_register (enum bfd_architecture architecture,
901 gdbarch_init_ftype *,
902 gdbarch_dump_tdep_ftype *);
903
104c1213 904
b4a20239
AC
905/* Return a freshly allocated, NULL terminated, array of the valid
906 architecture names. Since architectures are registered during the
907 _initialize phase this function only returns useful information
908 once initialization has been completed. */
909
910extern const char **gdbarch_printable_names (void);
911
912
104c1213
JM
913/* Helper function. Search the list of ARCHES for a GDBARCH that
914 matches the information provided by INFO. */
915
916extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
917
918
919/* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
920 basic initialization using values obtained from the INFO andTDEP
921 parameters. set_gdbarch_*() functions are called to complete the
922 initialization of the object. */
923
924extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
925
926
4b9b3959
AC
927/* Helper function. Free a partially-constructed \`\`struct gdbarch''.
928 It is assumed that the caller freeds the \`\`struct
929 gdbarch_tdep''. */
930
058f20d5
JB
931extern void gdbarch_free (struct gdbarch *);
932
933
b732d07d 934/* Helper function. Force an update of the current architecture.
104c1213 935
b732d07d
AC
936 The actual architecture selected is determined by INFO, \`\`(gdb) set
937 architecture'' et.al., the existing architecture and BFD's default
938 architecture. INFO should be initialized to zero and then selected
939 fields should be updated.
104c1213 940
16f33e29
AC
941 Returns non-zero if the update succeeds */
942
943extern int gdbarch_update_p (struct gdbarch_info info);
104c1213
JM
944
945
946
947/* Register per-architecture data-pointer.
948
949 Reserve space for a per-architecture data-pointer. An identifier
950 for the reserved data-pointer is returned. That identifer should
95160752 951 be saved in a local static variable.
104c1213 952
95160752
AC
953 The per-architecture data-pointer can be initialized in one of two
954 ways: The value can be set explicitly using a call to
955 set_gdbarch_data(); the value can be set implicitly using the value
956 returned by a non-NULL INIT() callback. INIT(), when non-NULL is
957 called after the basic architecture vector has been created.
104c1213 958
95160752
AC
959 When a previously created architecture is re-selected, the
960 per-architecture data-pointer for that previous architecture is
961 restored. INIT() is not called.
962
963 During initialization, multiple assignments of the data-pointer are
964 allowed, non-NULL values are deleted by calling FREE(). If the
965 architecture is deleted using gdbarch_free() all non-NULL data
966 pointers are also deleted using FREE().
104c1213
JM
967
968 Multiple registrarants for any architecture are allowed (and
969 strongly encouraged). */
970
95160752 971struct gdbarch_data;
104c1213 972
95160752
AC
973typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
974typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
975 void *pointer);
976extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
977 gdbarch_data_free_ftype *free);
978extern void set_gdbarch_data (struct gdbarch *gdbarch,
979 struct gdbarch_data *data,
980 void *pointer);
104c1213
JM
981
982extern void *gdbarch_data (struct gdbarch_data*);
983
984
104c1213
JM
985/* Register per-architecture memory region.
986
987 Provide a memory-region swap mechanism. Per-architecture memory
988 region are created. These memory regions are swapped whenever the
989 architecture is changed. For a new architecture, the memory region
990 is initialized with zero (0) and the INIT function is called.
991
992 Memory regions are swapped / initialized in the order that they are
993 registered. NULL DATA and/or INIT values can be specified.
994
995 New code should use register_gdbarch_data(). */
996
997typedef void (gdbarch_swap_ftype) (void);
998extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
e514a9d6 999#define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
104c1213
JM
1000
1001
1002
0fa6923a 1003/* The target-system-dependent byte order is dynamic */
104c1213
JM
1004
1005/* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
1006 is selectable at runtime. The user can use the \`\`set endian''
1007 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
1008 target_byte_order should be auto-detected (from the program image
1009 say). */
1010
1011#if GDB_MULTI_ARCH
1012/* Multi-arch GDB is always bi-endian. */
1013#define TARGET_BYTE_ORDER_SELECTABLE_P 1
1014#endif
1015
1016#ifndef TARGET_BYTE_ORDER_SELECTABLE_P
1017/* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
1018 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
1019#ifdef TARGET_BYTE_ORDER_SELECTABLE
1020#define TARGET_BYTE_ORDER_SELECTABLE_P 1
1021#else
1022#define TARGET_BYTE_ORDER_SELECTABLE_P 0
1023#endif
1024#endif
1025
1026extern int target_byte_order;
1027#ifdef TARGET_BYTE_ORDER_SELECTABLE
1028/* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
1029 and expect defs.h to re-define TARGET_BYTE_ORDER. */
1030#undef TARGET_BYTE_ORDER
1031#endif
1032#ifndef TARGET_BYTE_ORDER
1033#define TARGET_BYTE_ORDER (target_byte_order + 0)
1034#endif
1035
1036extern int target_byte_order_auto;
1037#ifndef TARGET_BYTE_ORDER_AUTO
1038#define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1039#endif
1040
1041
1042
0fa6923a 1043/* The target-system-dependent BFD architecture is dynamic */
104c1213
JM
1044
1045extern int target_architecture_auto;
1046#ifndef TARGET_ARCHITECTURE_AUTO
1047#define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1048#endif
1049
1050extern const struct bfd_arch_info *target_architecture;
1051#ifndef TARGET_ARCHITECTURE
1052#define TARGET_ARCHITECTURE (target_architecture + 0)
1053#endif
1054
104c1213 1055
0fa6923a 1056/* The target-system-dependent disassembler is semi-dynamic */
104c1213 1057
104c1213 1058extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
ff844c8d 1059 unsigned int len, disassemble_info *info);
104c1213
JM
1060
1061extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1062 disassemble_info *info);
1063
1064extern void dis_asm_print_address (bfd_vma addr,
1065 disassemble_info *info);
1066
1067extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1068extern disassemble_info tm_print_insn_info;
104c1213
JM
1069#ifndef TARGET_PRINT_INSN_INFO
1070#define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1071#endif
1072
1073
1074
0fa6923a 1075/* Set the dynamic target-system-dependent parameters (architecture,
104c1213
JM
1076 byte-order, ...) using information found in the BFD */
1077
1078extern void set_gdbarch_from_file (bfd *);
1079
1080
e514a9d6
JM
1081/* Initialize the current architecture to the "first" one we find on
1082 our list. */
1083
1084extern void initialize_current_architecture (void);
1085
ceaa8edf
JB
1086/* For non-multiarched targets, do any initialization of the default
1087 gdbarch object necessary after the _initialize_MODULE functions
1088 have run. */
1089extern void initialize_non_multiarch ();
104c1213
JM
1090
1091/* gdbarch trace variable */
1092extern int gdbarch_debug;
1093
4b9b3959 1094extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
104c1213
JM
1095
1096#endif
1097EOF
1098exec 1>&2
1099#../move-if-change new-gdbarch.h gdbarch.h
59233f88 1100compare_new gdbarch.h
104c1213
JM
1101
1102
1103#
1104# C file
1105#
1106
1107exec > new-gdbarch.c
1108copyright
1109cat <<EOF
1110
1111#include "defs.h"
7355ddba 1112#include "arch-utils.h"
104c1213
JM
1113
1114#if GDB_MULTI_ARCH
1115#include "gdbcmd.h"
1116#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1117#else
1118/* Just include everything in sight so that the every old definition
1119 of macro is visible. */
1120#include "gdb_string.h"
1121#include <ctype.h>
1122#include "symtab.h"
1123#include "frame.h"
1124#include "inferior.h"
1125#include "breakpoint.h"
0596389c 1126#include "gdb_wait.h"
104c1213
JM
1127#include "gdbcore.h"
1128#include "gdbcmd.h"
1129#include "target.h"
1130#include "gdbthread.h"
1131#include "annotate.h"
1132#include "symfile.h" /* for overlay functions */
fd0407d6 1133#include "value.h" /* For old tm.h/nm.h macros. */
104c1213
JM
1134#endif
1135#include "symcat.h"
1136
f0d4cc9e 1137#include "floatformat.h"
104c1213 1138
95160752 1139#include "gdb_assert.h"
67c2c32c 1140#include "gdb-events.h"
95160752 1141
104c1213
JM
1142/* Static function declarations */
1143
1144static void verify_gdbarch (struct gdbarch *gdbarch);
b3cc3077
JB
1145static void alloc_gdbarch_data (struct gdbarch *);
1146static void init_gdbarch_data (struct gdbarch *);
95160752 1147static void free_gdbarch_data (struct gdbarch *);
104c1213
JM
1148static void init_gdbarch_swap (struct gdbarch *);
1149static void swapout_gdbarch_swap (struct gdbarch *);
1150static void swapin_gdbarch_swap (struct gdbarch *);
1151
1152/* Convenience macro for allocting typesafe memory. */
1153
1154#ifndef XMALLOC
1155#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1156#endif
1157
1158
1159/* Non-zero if we want to trace architecture code. */
1160
1161#ifndef GDBARCH_DEBUG
1162#define GDBARCH_DEBUG 0
1163#endif
1164int gdbarch_debug = GDBARCH_DEBUG;
1165
1166EOF
1167
1168# gdbarch open the gdbarch object
3d9a5942
AC
1169printf "\n"
1170printf "/* Maintain the struct gdbarch object */\n"
1171printf "\n"
1172printf "struct gdbarch\n"
1173printf "{\n"
1174printf " /* basic architectural information */\n"
34620563 1175function_list | while do_read
104c1213 1176do
2ada493a
AC
1177 if class_is_info_p
1178 then
3d9a5942 1179 printf " ${returntype} ${function};\n"
2ada493a 1180 fi
104c1213 1181done
3d9a5942
AC
1182printf "\n"
1183printf " /* target specific vector. */\n"
1184printf " struct gdbarch_tdep *tdep;\n"
1185printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1186printf "\n"
1187printf " /* per-architecture data-pointers */\n"
95160752 1188printf " unsigned nr_data;\n"
3d9a5942
AC
1189printf " void **data;\n"
1190printf "\n"
1191printf " /* per-architecture swap-regions */\n"
1192printf " struct gdbarch_swap *swap;\n"
1193printf "\n"
104c1213
JM
1194cat <<EOF
1195 /* Multi-arch values.
1196
1197 When extending this structure you must:
1198
1199 Add the field below.
1200
1201 Declare set/get functions and define the corresponding
1202 macro in gdbarch.h.
1203
1204 gdbarch_alloc(): If zero/NULL is not a suitable default,
1205 initialize the new field.
1206
1207 verify_gdbarch(): Confirm that the target updated the field
1208 correctly.
1209
7e73cedf 1210 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
104c1213
JM
1211 field is dumped out
1212
c0e8c252 1213 \`\`startup_gdbarch()'': Append an initial value to the static
104c1213
JM
1214 variable (base values on the host's c-type system).
1215
1216 get_gdbarch(): Implement the set/get functions (probably using
1217 the macro's as shortcuts).
1218
1219 */
1220
1221EOF
34620563 1222function_list | while do_read
104c1213 1223do
2ada493a
AC
1224 if class_is_variable_p
1225 then
3d9a5942 1226 printf " ${returntype} ${function};\n"
2ada493a
AC
1227 elif class_is_function_p
1228 then
3d9a5942 1229 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
2ada493a 1230 fi
104c1213 1231done
3d9a5942 1232printf "};\n"
104c1213
JM
1233
1234# A pre-initialized vector
3d9a5942
AC
1235printf "\n"
1236printf "\n"
104c1213
JM
1237cat <<EOF
1238/* The default architecture uses host values (for want of a better
1239 choice). */
1240EOF
3d9a5942
AC
1241printf "\n"
1242printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1243printf "\n"
1244printf "struct gdbarch startup_gdbarch =\n"
1245printf "{\n"
1246printf " /* basic architecture information */\n"
4b9b3959 1247function_list | while do_read
104c1213 1248do
2ada493a
AC
1249 if class_is_info_p
1250 then
3d9a5942 1251 printf " ${staticdefault},\n"
2ada493a 1252 fi
104c1213
JM
1253done
1254cat <<EOF
4b9b3959
AC
1255 /* target specific vector and its dump routine */
1256 NULL, NULL,
104c1213
JM
1257 /*per-architecture data-pointers and swap regions */
1258 0, NULL, NULL,
1259 /* Multi-arch values */
1260EOF
34620563 1261function_list | while do_read
104c1213 1262do
2ada493a
AC
1263 if class_is_function_p || class_is_variable_p
1264 then
3d9a5942 1265 printf " ${staticdefault},\n"
2ada493a 1266 fi
104c1213
JM
1267done
1268cat <<EOF
c0e8c252 1269 /* startup_gdbarch() */
104c1213 1270};
4b9b3959 1271
c0e8c252 1272struct gdbarch *current_gdbarch = &startup_gdbarch;
ceaa8edf
JB
1273
1274/* Do any initialization needed for a non-multiarch configuration
1275 after the _initialize_MODULE functions have been run. */
1276void
1277initialize_non_multiarch ()
1278{
1279 alloc_gdbarch_data (&startup_gdbarch);
1280 init_gdbarch_data (&startup_gdbarch);
1281}
104c1213
JM
1282EOF
1283
1284# Create a new gdbarch struct
3d9a5942
AC
1285printf "\n"
1286printf "\n"
104c1213 1287cat <<EOF
66b43ecb 1288/* Create a new \`\`struct gdbarch'' based on information provided by
104c1213
JM
1289 \`\`struct gdbarch_info''. */
1290EOF
3d9a5942 1291printf "\n"
104c1213
JM
1292cat <<EOF
1293struct gdbarch *
1294gdbarch_alloc (const struct gdbarch_info *info,
1295 struct gdbarch_tdep *tdep)
1296{
85de9627
AC
1297 /* NOTE: The new architecture variable is named \`\`current_gdbarch''
1298 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
1299 the current local architecture and not the previous global
1300 architecture. This ensures that the new architectures initial
1301 values are not influenced by the previous architecture. Once
1302 everything is parameterised with gdbarch, this will go away. */
1303 struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
1304 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
1305
1306 alloc_gdbarch_data (current_gdbarch);
1307
1308 current_gdbarch->tdep = tdep;
104c1213 1309EOF
3d9a5942 1310printf "\n"
34620563 1311function_list | while do_read
104c1213 1312do
2ada493a
AC
1313 if class_is_info_p
1314 then
85de9627 1315 printf " current_gdbarch->${function} = info->${function};\n"
2ada493a 1316 fi
104c1213 1317done
3d9a5942
AC
1318printf "\n"
1319printf " /* Force the explicit initialization of these. */\n"
34620563 1320function_list | while do_read
104c1213 1321do
2ada493a
AC
1322 if class_is_function_p || class_is_variable_p
1323 then
72e74a21 1324 if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
104c1213 1325 then
85de9627 1326 printf " current_gdbarch->${function} = ${predefault};\n"
104c1213 1327 fi
2ada493a 1328 fi
104c1213
JM
1329done
1330cat <<EOF
1331 /* gdbarch_alloc() */
1332
85de9627 1333 return current_gdbarch;
104c1213
JM
1334}
1335EOF
1336
058f20d5 1337# Free a gdbarch struct.
3d9a5942
AC
1338printf "\n"
1339printf "\n"
058f20d5
JB
1340cat <<EOF
1341/* Free a gdbarch struct. This should never happen in normal
1342 operation --- once you've created a gdbarch, you keep it around.
1343 However, if an architecture's init function encounters an error
1344 building the structure, it may need to clean up a partially
1345 constructed gdbarch. */
4b9b3959 1346
058f20d5
JB
1347void
1348gdbarch_free (struct gdbarch *arch)
1349{
95160752
AC
1350 gdb_assert (arch != NULL);
1351 free_gdbarch_data (arch);
338d7c5c 1352 xfree (arch);
058f20d5
JB
1353}
1354EOF
1355
104c1213 1356# verify a new architecture
3d9a5942
AC
1357printf "\n"
1358printf "\n"
1359printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1360printf "\n"
104c1213
JM
1361cat <<EOF
1362static void
1363verify_gdbarch (struct gdbarch *gdbarch)
1364{
1365 /* Only perform sanity checks on a multi-arch target. */
6166d547 1366 if (!GDB_MULTI_ARCH)
104c1213
JM
1367 return;
1368 /* fundamental */
1369 if (gdbarch->byte_order == 0)
8e65ff28
AC
1370 internal_error (__FILE__, __LINE__,
1371 "verify_gdbarch: byte-order unset");
104c1213 1372 if (gdbarch->bfd_arch_info == NULL)
8e65ff28
AC
1373 internal_error (__FILE__, __LINE__,
1374 "verify_gdbarch: bfd_arch_info unset");
104c1213
JM
1375 /* Check those that need to be defined for the given multi-arch level. */
1376EOF
34620563 1377function_list | while do_read
104c1213 1378do
2ada493a
AC
1379 if class_is_function_p || class_is_variable_p
1380 then
72e74a21 1381 if [ "x${invalid_p}" = "x0" ]
c0e8c252 1382 then
3d9a5942 1383 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
2ada493a
AC
1384 elif class_is_predicate_p
1385 then
3d9a5942 1386 printf " /* Skip verify of ${function}, has predicate */\n"
f0d4cc9e 1387 # FIXME: See do_read for potential simplification
72e74a21 1388 elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
f0d4cc9e 1389 then
3d9a5942
AC
1390 printf " if (${invalid_p})\n"
1391 printf " gdbarch->${function} = ${postdefault};\n"
72e74a21 1392 elif [ -n "${predefault}" -a -n "${postdefault}" ]
f0d4cc9e 1393 then
3d9a5942
AC
1394 printf " if (gdbarch->${function} == ${predefault})\n"
1395 printf " gdbarch->${function} = ${postdefault};\n"
72e74a21 1396 elif [ -n "${postdefault}" ]
f0d4cc9e 1397 then
3d9a5942
AC
1398 printf " if (gdbarch->${function} == 0)\n"
1399 printf " gdbarch->${function} = ${postdefault};\n"
72e74a21 1400 elif [ -n "${invalid_p}" ]
104c1213 1401 then
3d9a5942
AC
1402 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1403 printf " && (${invalid_p}))\n"
8e65ff28
AC
1404 printf " internal_error (__FILE__, __LINE__,\n"
1405 printf " \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
72e74a21 1406 elif [ -n "${predefault}" ]
104c1213 1407 then
3d9a5942
AC
1408 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1409 printf " && (gdbarch->${function} == ${predefault}))\n"
8e65ff28
AC
1410 printf " internal_error (__FILE__, __LINE__,\n"
1411 printf " \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
104c1213 1412 fi
2ada493a 1413 fi
104c1213
JM
1414done
1415cat <<EOF
1416}
1417EOF
1418
1419# dump the structure
3d9a5942
AC
1420printf "\n"
1421printf "\n"
104c1213 1422cat <<EOF
4b9b3959
AC
1423/* Print out the details of the current architecture. */
1424
1425/* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1426 just happens to match the global variable \`\`current_gdbarch''. That
1427 way macros refering to that variable get the local and not the global
1428 version - ulgh. Once everything is parameterised with gdbarch, this
1429 will go away. */
1430
104c1213 1431void
4b9b3959 1432gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
104c1213 1433{
4b9b3959
AC
1434 fprintf_unfiltered (file,
1435 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1436 GDB_MULTI_ARCH);
104c1213 1437EOF
08e45a40 1438function_list | sort -t: +2 | while do_read
104c1213 1439do
4a5c6a1d 1440 # multiarch functions don't have macros.
08e45a40
AC
1441 if class_is_multiarch_p
1442 then
1443 printf " if (GDB_MULTI_ARCH)\n"
1444 printf " fprintf_unfiltered (file,\n"
1445 printf " \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1446 printf " (long) current_gdbarch->${function});\n"
1447 continue
1448 fi
1449 printf "#ifdef ${macro}\n"
72e74a21 1450 if [ "x${returntype}" = "xvoid" ]
63e69063 1451 then
08e45a40 1452 printf "#if GDB_MULTI_ARCH\n"
3d9a5942 1453 printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
63e69063 1454 fi
2ada493a
AC
1455 if class_is_function_p
1456 then
3d9a5942
AC
1457 printf " fprintf_unfiltered (file,\n"
1458 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1459 printf " \"${macro}(${actual})\",\n"
1460 printf " XSTRING (${macro} (${actual})));\n"
2ada493a 1461 else
3d9a5942
AC
1462 printf " fprintf_unfiltered (file,\n"
1463 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1464 printf " XSTRING (${macro}));\n"
4b9b3959 1465 fi
08e45a40 1466 if [ "x${returntype}" = "xvoid" ]
4a5c6a1d 1467 then
08e45a40 1468 printf "#endif\n"
4a5c6a1d 1469 fi
72e74a21 1470 if [ "x${print_p}" = "x()" ]
4b9b3959 1471 then
4a5c6a1d 1472 printf " gdbarch_dump_${function} (current_gdbarch);\n"
72e74a21 1473 elif [ "x${print_p}" = "x0" ]
4b9b3959 1474 then
4a5c6a1d 1475 printf " /* skip print of ${macro}, print_p == 0. */\n"
72e74a21 1476 elif [ -n "${print_p}" ]
4b9b3959 1477 then
4a5c6a1d 1478 printf " if (${print_p})\n"
3d9a5942
AC
1479 printf " fprintf_unfiltered (file,\n"
1480 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1481 printf " ${print});\n"
4b9b3959
AC
1482 elif class_is_function_p
1483 then
3d9a5942
AC
1484 printf " if (GDB_MULTI_ARCH)\n"
1485 printf " fprintf_unfiltered (file,\n"
1486 printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1487 printf " (long) current_gdbarch->${function}\n"
1488 printf " /*${macro} ()*/);\n"
4b9b3959 1489 else
3d9a5942
AC
1490 printf " fprintf_unfiltered (file,\n"
1491 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1492 printf " ${print});\n"
2ada493a 1493 fi
3d9a5942 1494 printf "#endif\n"
104c1213 1495done
381323f4 1496cat <<EOF
4b9b3959
AC
1497 if (current_gdbarch->dump_tdep != NULL)
1498 current_gdbarch->dump_tdep (current_gdbarch, file);
381323f4
AC
1499}
1500EOF
104c1213
JM
1501
1502
1503# GET/SET
3d9a5942 1504printf "\n"
104c1213
JM
1505cat <<EOF
1506struct gdbarch_tdep *
1507gdbarch_tdep (struct gdbarch *gdbarch)
1508{
1509 if (gdbarch_debug >= 2)
3d9a5942 1510 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
104c1213
JM
1511 return gdbarch->tdep;
1512}
1513EOF
3d9a5942 1514printf "\n"
34620563 1515function_list | while do_read
104c1213 1516do
2ada493a
AC
1517 if class_is_predicate_p
1518 then
3d9a5942
AC
1519 printf "\n"
1520 printf "int\n"
1521 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1522 printf "{\n"
72e74a21 1523 if [ -n "${valid_p}" ]
2ada493a 1524 then
3d9a5942 1525 printf " return ${valid_p};\n"
2ada493a 1526 else
3d9a5942 1527 printf "#error \"gdbarch_${function}_p: not defined\"\n"
2ada493a 1528 fi
3d9a5942 1529 printf "}\n"
2ada493a
AC
1530 fi
1531 if class_is_function_p
1532 then
3d9a5942
AC
1533 printf "\n"
1534 printf "${returntype}\n"
72e74a21 1535 if [ "x${formal}" = "xvoid" ]
104c1213 1536 then
3d9a5942 1537 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
104c1213 1538 else
3d9a5942 1539 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
104c1213 1540 fi
3d9a5942
AC
1541 printf "{\n"
1542 printf " if (gdbarch->${function} == 0)\n"
8e65ff28
AC
1543 printf " internal_error (__FILE__, __LINE__,\n"
1544 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
3d9a5942
AC
1545 printf " if (gdbarch_debug >= 2)\n"
1546 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
72e74a21 1547 if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
4a5c6a1d
AC
1548 then
1549 if class_is_multiarch_p
1550 then
1551 params="gdbarch"
1552 else
1553 params=""
1554 fi
1555 else
1556 if class_is_multiarch_p
1557 then
1558 params="gdbarch, ${actual}"
1559 else
1560 params="${actual}"
1561 fi
1562 fi
72e74a21 1563 if [ "x${returntype}" = "xvoid" ]
104c1213 1564 then
4a5c6a1d 1565 printf " gdbarch->${function} (${params});\n"
104c1213 1566 else
4a5c6a1d 1567 printf " return gdbarch->${function} (${params});\n"
104c1213 1568 fi
3d9a5942
AC
1569 printf "}\n"
1570 printf "\n"
1571 printf "void\n"
1572 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1573 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1574 printf "{\n"
1575 printf " gdbarch->${function} = ${function};\n"
1576 printf "}\n"
2ada493a
AC
1577 elif class_is_variable_p
1578 then
3d9a5942
AC
1579 printf "\n"
1580 printf "${returntype}\n"
1581 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1582 printf "{\n"
72e74a21 1583 if [ "x${invalid_p}" = "x0" ]
c0e8c252 1584 then
3d9a5942 1585 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
72e74a21 1586 elif [ -n "${invalid_p}" ]
104c1213 1587 then
3d9a5942 1588 printf " if (${invalid_p})\n"
8e65ff28
AC
1589 printf " internal_error (__FILE__, __LINE__,\n"
1590 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
72e74a21 1591 elif [ -n "${predefault}" ]
104c1213 1592 then
3d9a5942 1593 printf " if (gdbarch->${function} == ${predefault})\n"
8e65ff28
AC
1594 printf " internal_error (__FILE__, __LINE__,\n"
1595 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
104c1213 1596 fi
3d9a5942
AC
1597 printf " if (gdbarch_debug >= 2)\n"
1598 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1599 printf " return gdbarch->${function};\n"
1600 printf "}\n"
1601 printf "\n"
1602 printf "void\n"
1603 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1604 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1605 printf "{\n"
1606 printf " gdbarch->${function} = ${function};\n"
1607 printf "}\n"
2ada493a
AC
1608 elif class_is_info_p
1609 then
3d9a5942
AC
1610 printf "\n"
1611 printf "${returntype}\n"
1612 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1613 printf "{\n"
1614 printf " if (gdbarch_debug >= 2)\n"
1615 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1616 printf " return gdbarch->${function};\n"
1617 printf "}\n"
2ada493a 1618 fi
104c1213
JM
1619done
1620
1621# All the trailing guff
1622cat <<EOF
1623
1624
f44c642f 1625/* Keep a registry of per-architecture data-pointers required by GDB
104c1213
JM
1626 modules. */
1627
1628struct gdbarch_data
1629{
95160752
AC
1630 unsigned index;
1631 gdbarch_data_init_ftype *init;
1632 gdbarch_data_free_ftype *free;
104c1213
JM
1633};
1634
1635struct gdbarch_data_registration
1636{
104c1213
JM
1637 struct gdbarch_data *data;
1638 struct gdbarch_data_registration *next;
1639};
1640
f44c642f 1641struct gdbarch_data_registry
104c1213 1642{
95160752 1643 unsigned nr;
104c1213
JM
1644 struct gdbarch_data_registration *registrations;
1645};
1646
f44c642f 1647struct gdbarch_data_registry gdbarch_data_registry =
104c1213
JM
1648{
1649 0, NULL,
1650};
1651
1652struct gdbarch_data *
95160752
AC
1653register_gdbarch_data (gdbarch_data_init_ftype *init,
1654 gdbarch_data_free_ftype *free)
104c1213
JM
1655{
1656 struct gdbarch_data_registration **curr;
f44c642f 1657 for (curr = &gdbarch_data_registry.registrations;
104c1213
JM
1658 (*curr) != NULL;
1659 curr = &(*curr)->next);
1660 (*curr) = XMALLOC (struct gdbarch_data_registration);
1661 (*curr)->next = NULL;
104c1213 1662 (*curr)->data = XMALLOC (struct gdbarch_data);
f44c642f 1663 (*curr)->data->index = gdbarch_data_registry.nr++;
95160752
AC
1664 (*curr)->data->init = init;
1665 (*curr)->data->free = free;
104c1213
JM
1666 return (*curr)->data;
1667}
1668
1669
b3cc3077 1670/* Walk through all the registered users initializing each in turn. */
104c1213
JM
1671
1672static void
b3cc3077 1673init_gdbarch_data (struct gdbarch *gdbarch)
104c1213 1674{
b3cc3077
JB
1675 struct gdbarch_data_registration *rego;
1676 for (rego = gdbarch_data_registry.registrations;
1677 rego != NULL;
1678 rego = rego->next)
104c1213 1679 {
b3cc3077
JB
1680 struct gdbarch_data *data = rego->data;
1681 gdb_assert (data->index < gdbarch->nr_data);
1682 if (data->init != NULL)
95160752 1683 {
b3cc3077
JB
1684 void *pointer = data->init (gdbarch);
1685 set_gdbarch_data (gdbarch, data, pointer);
95160752
AC
1686 }
1687 }
1688}
1689
b3cc3077 1690/* Create/delete the gdbarch data vector. */
95160752
AC
1691
1692static void
b3cc3077 1693alloc_gdbarch_data (struct gdbarch *gdbarch)
95160752 1694{
b3cc3077
JB
1695 gdb_assert (gdbarch->data == NULL);
1696 gdbarch->nr_data = gdbarch_data_registry.nr;
1697 gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1698}
3c875b6f 1699
b3cc3077
JB
1700static void
1701free_gdbarch_data (struct gdbarch *gdbarch)
1702{
1703 struct gdbarch_data_registration *rego;
1704 gdb_assert (gdbarch->data != NULL);
1705 for (rego = gdbarch_data_registry.registrations;
1706 rego != NULL;
1707 rego = rego->next)
95160752 1708 {
b3cc3077
JB
1709 struct gdbarch_data *data = rego->data;
1710 gdb_assert (data->index < gdbarch->nr_data);
1711 if (data->free != NULL && gdbarch->data[data->index] != NULL)
95160752 1712 {
b3cc3077
JB
1713 data->free (gdbarch, gdbarch->data[data->index]);
1714 gdbarch->data[data->index] = NULL;
95160752 1715 }
104c1213 1716 }
b3cc3077
JB
1717 xfree (gdbarch->data);
1718 gdbarch->data = NULL;
104c1213
JM
1719}
1720
1721
b3cc3077
JB
1722/* Initialize the current value of thee specified per-architecture
1723 data-pointer. */
1724
95160752
AC
1725void
1726set_gdbarch_data (struct gdbarch *gdbarch,
1727 struct gdbarch_data *data,
1728 void *pointer)
1729{
1730 gdb_assert (data->index < gdbarch->nr_data);
1731 if (data->free != NULL && gdbarch->data[data->index] != NULL)
1732 data->free (gdbarch, gdbarch->data[data->index]);
1733 gdbarch->data[data->index] = pointer;
1734}
1735
104c1213
JM
1736/* Return the current value of the specified per-architecture
1737 data-pointer. */
1738
1739void *
34620563 1740gdbarch_data (struct gdbarch_data *data)
104c1213 1741{
95160752 1742 gdb_assert (data->index < current_gdbarch->nr_data);
104c1213
JM
1743 return current_gdbarch->data[data->index];
1744}
1745
1746
1747
f44c642f 1748/* Keep a registry of swapped data required by GDB modules. */
104c1213
JM
1749
1750struct gdbarch_swap
1751{
1752 void *swap;
1753 struct gdbarch_swap_registration *source;
1754 struct gdbarch_swap *next;
1755};
1756
1757struct gdbarch_swap_registration
1758{
1759 void *data;
1760 unsigned long sizeof_data;
1761 gdbarch_swap_ftype *init;
1762 struct gdbarch_swap_registration *next;
1763};
1764
f44c642f 1765struct gdbarch_swap_registry
104c1213
JM
1766{
1767 int nr;
1768 struct gdbarch_swap_registration *registrations;
1769};
1770
f44c642f 1771struct gdbarch_swap_registry gdbarch_swap_registry =
104c1213
JM
1772{
1773 0, NULL,
1774};
1775
1776void
1777register_gdbarch_swap (void *data,
1778 unsigned long sizeof_data,
1779 gdbarch_swap_ftype *init)
1780{
1781 struct gdbarch_swap_registration **rego;
f44c642f 1782 for (rego = &gdbarch_swap_registry.registrations;
104c1213
JM
1783 (*rego) != NULL;
1784 rego = &(*rego)->next);
1785 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1786 (*rego)->next = NULL;
1787 (*rego)->init = init;
1788 (*rego)->data = data;
1789 (*rego)->sizeof_data = sizeof_data;
1790}
1791
1792
1793static void
1794init_gdbarch_swap (struct gdbarch *gdbarch)
1795{
1796 struct gdbarch_swap_registration *rego;
1797 struct gdbarch_swap **curr = &gdbarch->swap;
f44c642f 1798 for (rego = gdbarch_swap_registry.registrations;
104c1213
JM
1799 rego != NULL;
1800 rego = rego->next)
1801 {
1802 if (rego->data != NULL)
1803 {
1804 (*curr) = XMALLOC (struct gdbarch_swap);
1805 (*curr)->source = rego;
1806 (*curr)->swap = xmalloc (rego->sizeof_data);
1807 (*curr)->next = NULL;
1808 memset (rego->data, 0, rego->sizeof_data);
1809 curr = &(*curr)->next;
1810 }
1811 if (rego->init != NULL)
1812 rego->init ();
1813 }
1814}
1815
1816static void
1817swapout_gdbarch_swap (struct gdbarch *gdbarch)
1818{
1819 struct gdbarch_swap *curr;
1820 for (curr = gdbarch->swap;
1821 curr != NULL;
1822 curr = curr->next)
1823 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1824}
1825
1826static void
1827swapin_gdbarch_swap (struct gdbarch *gdbarch)
1828{
1829 struct gdbarch_swap *curr;
1830 for (curr = gdbarch->swap;
1831 curr != NULL;
1832 curr = curr->next)
1833 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1834}
1835
1836
f44c642f 1837/* Keep a registry of the architectures known by GDB. */
104c1213 1838
4b9b3959 1839struct gdbarch_registration
104c1213
JM
1840{
1841 enum bfd_architecture bfd_architecture;
1842 gdbarch_init_ftype *init;
4b9b3959 1843 gdbarch_dump_tdep_ftype *dump_tdep;
104c1213 1844 struct gdbarch_list *arches;
4b9b3959 1845 struct gdbarch_registration *next;
104c1213
JM
1846};
1847
f44c642f 1848static struct gdbarch_registration *gdbarch_registry = NULL;
104c1213 1849
b4a20239
AC
1850static void
1851append_name (const char ***buf, int *nr, const char *name)
1852{
1853 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1854 (*buf)[*nr] = name;
1855 *nr += 1;
1856}
1857
1858const char **
1859gdbarch_printable_names (void)
1860{
1861 if (GDB_MULTI_ARCH)
1862 {
1863 /* Accumulate a list of names based on the registed list of
1864 architectures. */
1865 enum bfd_architecture a;
1866 int nr_arches = 0;
1867 const char **arches = NULL;
4b9b3959 1868 struct gdbarch_registration *rego;
f44c642f 1869 for (rego = gdbarch_registry;
b4a20239
AC
1870 rego != NULL;
1871 rego = rego->next)
1872 {
1873 const struct bfd_arch_info *ap;
1874 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1875 if (ap == NULL)
8e65ff28
AC
1876 internal_error (__FILE__, __LINE__,
1877 "gdbarch_architecture_names: multi-arch unknown");
b4a20239
AC
1878 do
1879 {
1880 append_name (&arches, &nr_arches, ap->printable_name);
1881 ap = ap->next;
1882 }
1883 while (ap != NULL);
1884 }
1885 append_name (&arches, &nr_arches, NULL);
1886 return arches;
1887 }
1888 else
1889 /* Just return all the architectures that BFD knows. Assume that
1890 the legacy architecture framework supports them. */
1891 return bfd_arch_list ();
1892}
1893
1894
104c1213 1895void
4b9b3959
AC
1896gdbarch_register (enum bfd_architecture bfd_architecture,
1897 gdbarch_init_ftype *init,
1898 gdbarch_dump_tdep_ftype *dump_tdep)
104c1213 1899{
4b9b3959 1900 struct gdbarch_registration **curr;
104c1213 1901 const struct bfd_arch_info *bfd_arch_info;
ec3d358c 1902 /* Check that BFD recognizes this architecture */
104c1213
JM
1903 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1904 if (bfd_arch_info == NULL)
1905 {
8e65ff28
AC
1906 internal_error (__FILE__, __LINE__,
1907 "gdbarch: Attempt to register unknown architecture (%d)",
1908 bfd_architecture);
104c1213
JM
1909 }
1910 /* Check that we haven't seen this architecture before */
f44c642f 1911 for (curr = &gdbarch_registry;
104c1213
JM
1912 (*curr) != NULL;
1913 curr = &(*curr)->next)
1914 {
1915 if (bfd_architecture == (*curr)->bfd_architecture)
8e65ff28
AC
1916 internal_error (__FILE__, __LINE__,
1917 "gdbarch: Duplicate registraration of architecture (%s)",
1918 bfd_arch_info->printable_name);
104c1213
JM
1919 }
1920 /* log it */
1921 if (gdbarch_debug)
1922 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1923 bfd_arch_info->printable_name,
1924 (long) init);
1925 /* Append it */
4b9b3959 1926 (*curr) = XMALLOC (struct gdbarch_registration);
104c1213
JM
1927 (*curr)->bfd_architecture = bfd_architecture;
1928 (*curr)->init = init;
4b9b3959 1929 (*curr)->dump_tdep = dump_tdep;
104c1213
JM
1930 (*curr)->arches = NULL;
1931 (*curr)->next = NULL;
8e1a459b
C
1932 /* When non- multi-arch, install whatever target dump routine we've
1933 been provided - hopefully that routine has been written correctly
4b9b3959
AC
1934 and works regardless of multi-arch. */
1935 if (!GDB_MULTI_ARCH && dump_tdep != NULL
1936 && startup_gdbarch.dump_tdep == NULL)
1937 startup_gdbarch.dump_tdep = dump_tdep;
1938}
1939
1940void
1941register_gdbarch_init (enum bfd_architecture bfd_architecture,
1942 gdbarch_init_ftype *init)
1943{
1944 gdbarch_register (bfd_architecture, init, NULL);
104c1213 1945}
104c1213
JM
1946
1947
1948/* Look for an architecture using gdbarch_info. Base search on only
1949 BFD_ARCH_INFO and BYTE_ORDER. */
1950
1951struct gdbarch_list *
1952gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1953 const struct gdbarch_info *info)
1954{
1955 for (; arches != NULL; arches = arches->next)
1956 {
1957 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1958 continue;
1959 if (info->byte_order != arches->gdbarch->byte_order)
1960 continue;
1961 return arches;
1962 }
1963 return NULL;
1964}
1965
1966
1967/* Update the current architecture. Return ZERO if the update request
1968 failed. */
1969
1970int
16f33e29 1971gdbarch_update_p (struct gdbarch_info info)
104c1213
JM
1972{
1973 struct gdbarch *new_gdbarch;
1974 struct gdbarch_list **list;
4b9b3959 1975 struct gdbarch_registration *rego;
104c1213 1976
b732d07d
AC
1977 /* Fill in missing parts of the INFO struct using a number of
1978 sources: \`\`set ...''; INFOabfd supplied; existing target. */
1979
1980 /* \`\`(gdb) set architecture ...'' */
1981 if (info.bfd_arch_info == NULL
1982 && !TARGET_ARCHITECTURE_AUTO)
1983 info.bfd_arch_info = TARGET_ARCHITECTURE;
1984 if (info.bfd_arch_info == NULL
1985 && info.abfd != NULL
1986 && bfd_get_arch (info.abfd) != bfd_arch_unknown
1987 && bfd_get_arch (info.abfd) != bfd_arch_obscure)
1988 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
104c1213 1989 if (info.bfd_arch_info == NULL)
b732d07d
AC
1990 info.bfd_arch_info = TARGET_ARCHITECTURE;
1991
1992 /* \`\`(gdb) set byte-order ...'' */
1993 if (info.byte_order == 0
1994 && !TARGET_BYTE_ORDER_AUTO)
1995 info.byte_order = TARGET_BYTE_ORDER;
1996 /* From the INFO struct. */
1997 if (info.byte_order == 0
1998 && info.abfd != NULL)
1999 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
2000 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
2001 : 0);
2002 /* From the current target. */
104c1213 2003 if (info.byte_order == 0)
b732d07d 2004 info.byte_order = TARGET_BYTE_ORDER;
104c1213 2005
b732d07d
AC
2006 /* Must have found some sort of architecture. */
2007 gdb_assert (info.bfd_arch_info != NULL);
104c1213
JM
2008
2009 if (gdbarch_debug)
2010 {
2011 fprintf_unfiltered (gdb_stdlog,
b732d07d 2012 "gdbarch_update: info.bfd_arch_info %s\n",
104c1213
JM
2013 (info.bfd_arch_info != NULL
2014 ? info.bfd_arch_info->printable_name
2015 : "(null)"));
2016 fprintf_unfiltered (gdb_stdlog,
b732d07d 2017 "gdbarch_update: info.byte_order %d (%s)\n",
104c1213
JM
2018 info.byte_order,
2019 (info.byte_order == BIG_ENDIAN ? "big"
2020 : info.byte_order == LITTLE_ENDIAN ? "little"
2021 : "default"));
2022 fprintf_unfiltered (gdb_stdlog,
b732d07d 2023 "gdbarch_update: info.abfd 0x%lx\n",
104c1213
JM
2024 (long) info.abfd);
2025 fprintf_unfiltered (gdb_stdlog,
b732d07d 2026 "gdbarch_update: info.tdep_info 0x%lx\n",
104c1213
JM
2027 (long) info.tdep_info);
2028 }
2029
b732d07d
AC
2030 /* Find the target that knows about this architecture. */
2031 for (rego = gdbarch_registry;
2032 rego != NULL;
2033 rego = rego->next)
2034 if (rego->bfd_architecture == info.bfd_arch_info->arch)
2035 break;
2036 if (rego == NULL)
2037 {
2038 if (gdbarch_debug)
2039 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
2040 return 0;
2041 }
2042
104c1213
JM
2043 /* Ask the target for a replacement architecture. */
2044 new_gdbarch = rego->init (info, rego->arches);
2045
2046 /* Did the target like it? No. Reject the change. */
2047 if (new_gdbarch == NULL)
2048 {
2049 if (gdbarch_debug)
3d9a5942 2050 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
104c1213
JM
2051 return 0;
2052 }
2053
2054 /* Did the architecture change? No. Do nothing. */
2055 if (current_gdbarch == new_gdbarch)
2056 {
2057 if (gdbarch_debug)
3d9a5942 2058 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
104c1213
JM
2059 (long) new_gdbarch,
2060 new_gdbarch->bfd_arch_info->printable_name);
2061 return 1;
2062 }
2063
2064 /* Swap all data belonging to the old target out */
2065 swapout_gdbarch_swap (current_gdbarch);
2066
2067 /* Is this a pre-existing architecture? Yes. Swap it in. */
2068 for (list = &rego->arches;
2069 (*list) != NULL;
2070 list = &(*list)->next)
2071 {
2072 if ((*list)->gdbarch == new_gdbarch)
2073 {
2074 if (gdbarch_debug)
4b9b3959 2075 fprintf_unfiltered (gdb_stdlog,
3d9a5942 2076 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
104c1213
JM
2077 (long) new_gdbarch,
2078 new_gdbarch->bfd_arch_info->printable_name);
2079 current_gdbarch = new_gdbarch;
2080 swapin_gdbarch_swap (new_gdbarch);
67c2c32c 2081 architecture_changed_event ();
104c1213
JM
2082 return 1;
2083 }
2084 }
4b9b3959 2085
104c1213
JM
2086 /* Append this new architecture to this targets list. */
2087 (*list) = XMALLOC (struct gdbarch_list);
2088 (*list)->next = NULL;
2089 (*list)->gdbarch = new_gdbarch;
2090
2091 /* Switch to this new architecture. Dump it out. */
2092 current_gdbarch = new_gdbarch;
2093 if (gdbarch_debug)
2094 {
2095 fprintf_unfiltered (gdb_stdlog,
3d9a5942 2096 "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
104c1213
JM
2097 (long) new_gdbarch,
2098 new_gdbarch->bfd_arch_info->printable_name);
104c1213
JM
2099 }
2100
4b9b3959
AC
2101 /* Check that the newly installed architecture is valid. Plug in
2102 any post init values. */
2103 new_gdbarch->dump_tdep = rego->dump_tdep;
104c1213
JM
2104 verify_gdbarch (new_gdbarch);
2105
2106 /* Initialize the per-architecture memory (swap) areas.
2107 CURRENT_GDBARCH must be update before these modules are
2108 called. */
2109 init_gdbarch_swap (new_gdbarch);
2110
b3cc3077
JB
2111 /* Initialize the per-architecture data-pointer of all parties that
2112 registered an interest in this architecture. CURRENT_GDBARCH
2113 must be updated before these modules are called. */
2114 init_gdbarch_data (new_gdbarch);
67c2c32c
KS
2115 architecture_changed_event ();
2116
4b9b3959
AC
2117 if (gdbarch_debug)
2118 gdbarch_dump (current_gdbarch, gdb_stdlog);
2119
104c1213
JM
2120 return 1;
2121}
2122
2123
104c1213
JM
2124/* Disassembler */
2125
2126/* Pointer to the target-dependent disassembly function. */
2127int (*tm_print_insn) (bfd_vma, disassemble_info *);
2128disassemble_info tm_print_insn_info;
2129
2130
104c1213 2131extern void _initialize_gdbarch (void);
b4a20239 2132
104c1213 2133void
34620563 2134_initialize_gdbarch (void)
104c1213 2135{
59233f88
AC
2136 struct cmd_list_element *c;
2137
104c1213
JM
2138 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2139 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2140 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2141 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2142 tm_print_insn_info.print_address_func = dis_asm_print_address;
2143
59233f88 2144 add_show_from_set (add_set_cmd ("arch",
104c1213
JM
2145 class_maintenance,
2146 var_zinteger,
2147 (char *)&gdbarch_debug,
3d9a5942 2148 "Set architecture debugging.\\n\\
59233f88
AC
2149When non-zero, architecture debugging is enabled.", &setdebuglist),
2150 &showdebuglist);
2151 c = add_set_cmd ("archdebug",
2152 class_maintenance,
2153 var_zinteger,
2154 (char *)&gdbarch_debug,
3d9a5942 2155 "Set architecture debugging.\\n\\
59233f88
AC
2156When non-zero, architecture debugging is enabled.", &setlist);
2157
2158 deprecate_cmd (c, "set debug arch");
2159 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
104c1213
JM
2160}
2161EOF
2162
2163# close things off
2164exec 1>&2
2165#../move-if-change new-gdbarch.c gdbarch.c
59233f88 2166compare_new gdbarch.c
This page took 0.241429 seconds and 4 git commands to generate.