OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [gdbarch.sh] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
#!/bin/sh -u
2
 
3
# Architecture commands for GDB, the GNU debugger.
4
#
5
# Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
6
# 2008, 2009, 2010 Free Software Foundation, Inc.
7
#
8
# This file is part of GDB.
9
#
10
# This program is free software; you can redistribute it and/or modify
11
# it under the terms of the GNU General Public License as published by
12
# the Free Software Foundation; either version 3 of the License, or
13
# (at your option) any later version.
14
#
15
# This program is distributed in the hope that it will be useful,
16
# but WITHOUT ANY WARRANTY; without even the implied warranty of
17
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
# GNU General Public License for more details.
19
#
20
# You should have received a copy of the GNU General Public License
21
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
 
23
# Make certain that the script is not running in an internationalized
24
# environment.
25
LANG=C ; export LANG
26
LC_ALL=C ; export LC_ALL
27
 
28
 
29
compare_new ()
30
{
31
    file=$1
32
    if test ! -r ${file}
33
    then
34
        echo "${file} missing? cp new-${file} ${file}" 1>&2
35
    elif diff -u ${file} new-${file}
36
    then
37
        echo "${file} unchanged" 1>&2
38
    else
39
        echo "${file} has changed? cp new-${file} ${file}" 1>&2
40
    fi
41
}
42
 
43
 
44
# Format of the input table
45
read="class returntype function formal actual staticdefault predefault postdefault invalid_p print garbage_at_eol"
46
 
47
do_read ()
48
{
49
    comment=""
50
    class=""
51
    while read line
52
    do
53
        if test "${line}" = ""
54
        then
55
            continue
56
        elif test "${line}" = "#" -a "${comment}" = ""
57
        then
58
            continue
59
        elif expr "${line}" : "#" > /dev/null
60
        then
61
            comment="${comment}
62
${line}"
63
        else
64
 
65
            # The semantics of IFS varies between different SH's.  Some
66
            # treat ``::' as three fields while some treat it as just too.
67
            # Work around this by eliminating ``::'' ....
68
            line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
69
 
70
            OFS="${IFS}" ; IFS="[:]"
71
            eval read ${read} <<EOF
72
${line}
73
EOF
74
            IFS="${OFS}"
75
 
76
            if test -n "${garbage_at_eol}"
77
            then
78
                echo "Garbage at end-of-line in ${line}" 1>&2
79
                kill $$
80
                exit 1
81
            fi
82
 
83
            # .... and then going back through each field and strip out those
84
            # that ended up with just that space character.
85
            for r in ${read}
86
            do
87
                if eval test \"\${${r}}\" = \"\ \"
88
                then
89
                    eval ${r}=""
90
                fi
91
            done
92
 
93
            case "${class}" in
94
                m ) staticdefault="${predefault}" ;;
95
                M ) staticdefault="0" ;;
96
                * ) test "${staticdefault}" || staticdefault=0 ;;
97
            esac
98
 
99
            case "${class}" in
100
            F | V | M )
101
                case "${invalid_p}" in
102
                "" )
103
                    if test -n "${predefault}"
104
                    then
105
                        #invalid_p="gdbarch->${function} == ${predefault}"
106
                        predicate="gdbarch->${function} != ${predefault}"
107
                    elif class_is_variable_p
108
                    then
109
                        predicate="gdbarch->${function} != 0"
110
                    elif class_is_function_p
111
                    then
112
                        predicate="gdbarch->${function} != NULL"
113
                    fi
114
                    ;;
115
                * )
116
                    echo "Predicate function ${function} with invalid_p." 1>&2
117
                    kill $$
118
                    exit 1
119
                    ;;
120
                esac
121
            esac
122
 
123
            # PREDEFAULT is a valid fallback definition of MEMBER when
124
            # multi-arch is not enabled.  This ensures that the
125
            # default value, when multi-arch is the same as the
126
            # default value when not multi-arch.  POSTDEFAULT is
127
            # always a valid definition of MEMBER as this again
128
            # ensures consistency.
129
 
130
            if [ -n "${postdefault}" ]
131
            then
132
                fallbackdefault="${postdefault}"
133
            elif [ -n "${predefault}" ]
134
            then
135
                fallbackdefault="${predefault}"
136
            else
137
                fallbackdefault="0"
138
            fi
139
 
140
            #NOT YET: See gdbarch.log for basic verification of
141
            # database
142
 
143
            break
144
        fi
145
    done
146
    if [ -n "${class}" ]
147
    then
148
        true
149
    else
150
        false
151
    fi
152
}
153
 
154
 
155
fallback_default_p ()
156
{
157
    [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
158
        || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
159
}
160
 
161
class_is_variable_p ()
162
{
163
    case "${class}" in
164
        *v* | *V* ) true ;;
165
        * ) false ;;
166
    esac
167
}
168
 
169
class_is_function_p ()
170
{
171
    case "${class}" in
172
        *f* | *F* | *m* | *M* ) true ;;
173
        * ) false ;;
174
    esac
175
}
176
 
177
class_is_multiarch_p ()
178
{
179
    case "${class}" in
180
        *m* | *M* ) true ;;
181
        * ) false ;;
182
    esac
183
}
184
 
185
class_is_predicate_p ()
186
{
187
    case "${class}" in
188
        *F* | *V* | *M* ) true ;;
189
        * ) false ;;
190
    esac
191
}
192
 
193
class_is_info_p ()
194
{
195
    case "${class}" in
196
        *i* ) true ;;
197
        * ) false ;;
198
    esac
199
}
200
 
201
 
202
# dump out/verify the doco
203
for field in ${read}
204
do
205
  case ${field} in
206
 
207
    class ) : ;;
208
 
209
        # # -> line disable
210
        # f -> function
211
        #   hiding a function
212
        # F -> function + predicate
213
        #   hiding a function + predicate to test function validity
214
        # v -> variable
215
        #   hiding a variable
216
        # V -> variable + predicate
217
        #   hiding a variable + predicate to test variables validity
218
        # i -> set from info
219
        #   hiding something from the ``struct info'' object
220
        # m -> multi-arch function
221
        #   hiding a multi-arch function (parameterised with the architecture)
222
        # M -> multi-arch function + predicate
223
        #   hiding a multi-arch function + predicate to test function validity
224
 
225
    returntype ) : ;;
226
 
227
        # For functions, the return type; for variables, the data type
228
 
229
    function ) : ;;
230
 
231
        # For functions, the member function name; for variables, the
232
        # variable name.  Member function names are always prefixed with
233
        # ``gdbarch_'' for name-space purity.
234
 
235
    formal ) : ;;
236
 
237
        # The formal argument list.  It is assumed that the formal
238
        # argument list includes the actual name of each list element.
239
        # A function with no arguments shall have ``void'' as the
240
        # formal argument list.
241
 
242
    actual ) : ;;
243
 
244
        # The list of actual arguments.  The arguments specified shall
245
        # match the FORMAL list given above.  Functions with out
246
        # arguments leave this blank.
247
 
248
    staticdefault ) : ;;
249
 
250
        # To help with the GDB startup a static gdbarch object is
251
        # created.  STATICDEFAULT is the value to insert into that
252
        # static gdbarch object.  Since this a static object only
253
        # simple expressions can be used.
254
 
255
        # If STATICDEFAULT is empty, zero is used.
256
 
257
    predefault ) : ;;
258
 
259
        # An initial value to assign to MEMBER of the freshly
260
        # malloc()ed gdbarch object.  After initialization, the
261
        # freshly malloc()ed object is passed to the target
262
        # architecture code for further updates.
263
 
264
        # If PREDEFAULT is empty, zero is used.
265
 
266
        # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
267
        # INVALID_P are specified, PREDEFAULT will be used as the
268
        # default for the non- multi-arch target.
269
 
270
        # A zero PREDEFAULT function will force the fallback to call
271
        # internal_error().
272
 
273
        # Variable declarations can refer to ``gdbarch'' which will
274
        # contain the current architecture.  Care should be taken.
275
 
276
    postdefault ) : ;;
277
 
278
        # A value to assign to MEMBER of the new gdbarch object should
279
        # the target architecture code fail to change the PREDEFAULT
280
        # value.
281
 
282
        # If POSTDEFAULT is empty, no post update is performed.
283
 
284
        # If both INVALID_P and POSTDEFAULT are non-empty then
285
        # INVALID_P will be used to determine if MEMBER should be
286
        # changed to POSTDEFAULT.
287
 
288
        # If a non-empty POSTDEFAULT and a zero INVALID_P are
289
        # specified, POSTDEFAULT will be used as the default for the
290
        # non- multi-arch target (regardless of the value of
291
        # PREDEFAULT).
292
 
293
        # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
294
 
295
        # Variable declarations can refer to ``gdbarch'' which
296
        # will contain the current architecture.  Care should be
297
        # taken.
298
 
299
    invalid_p ) : ;;
300
 
301
        # A predicate equation that validates MEMBER.  Non-zero is
302
        # returned if the code creating the new architecture failed to
303
        # initialize MEMBER or the initialized the member is invalid.
304
        # If POSTDEFAULT is non-empty then MEMBER will be updated to
305
        # that value.  If POSTDEFAULT is empty then internal_error()
306
        # is called.
307
 
308
        # If INVALID_P is empty, a check that MEMBER is no longer
309
        # equal to PREDEFAULT is used.
310
 
311
        # The expression ``0'' disables the INVALID_P check making
312
        # PREDEFAULT a legitimate value.
313
 
314
        # See also PREDEFAULT and POSTDEFAULT.
315
 
316
    print ) : ;;
317
 
318
        # An optional expression that convers MEMBER to a value
319
        # suitable for formatting using %s.
320
 
321
        # If PRINT is empty, core_addr_to_string_nz (for CORE_ADDR)
322
        # or plongest (anything else) is used.
323
 
324
    garbage_at_eol ) : ;;
325
 
326
        # Catches stray fields.
327
 
328
    *)
329
        echo "Bad field ${field}"
330
        exit 1;;
331
  esac
332
done
333
 
334
 
335
function_list ()
336
{
337
  # See below (DOCO) for description of each field
338
  cat <<EOF
339
i:const struct bfd_arch_info *:bfd_arch_info:::&bfd_default_arch_struct::::gdbarch_bfd_arch_info (gdbarch)->printable_name
340
#
341
i:int:byte_order:::BFD_ENDIAN_BIG
342
i:int:byte_order_for_code:::BFD_ENDIAN_BIG
343
#
344
i:enum gdb_osabi:osabi:::GDB_OSABI_UNKNOWN
345
#
346
i:const struct target_desc *:target_desc:::::::host_address_to_string (gdbarch->target_desc)
347
 
348
# The bit byte-order has to do just with numbering of bits in debugging symbols
349
# and such.  Conceptually, it's quite separate from byte/word byte order.
350
v:int:bits_big_endian:::1:(gdbarch->byte_order == BFD_ENDIAN_BIG)::0
351
 
352
# Number of bits in a char or unsigned char for the target machine.
353
# Just like CHAR_BIT in <limits.h> but describes the target machine.
354
# v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
355
#
356
# Number of bits in a short or unsigned short for the target machine.
357
v:int:short_bit:::8 * sizeof (short):2*TARGET_CHAR_BIT::0
358
# Number of bits in an int or unsigned int for the target machine.
359
v:int:int_bit:::8 * sizeof (int):4*TARGET_CHAR_BIT::0
360
# Number of bits in a long or unsigned long for the target machine.
361
v:int:long_bit:::8 * sizeof (long):4*TARGET_CHAR_BIT::0
362
# Number of bits in a long long or unsigned long long for the target
363
# machine.
364
v:int:long_long_bit:::8 * sizeof (LONGEST):2*gdbarch->long_bit::0
365
 
366
# The ABI default bit-size and format for "float", "double", and "long
367
# double".  These bit/format pairs should eventually be combined into
368
# a single object.  For the moment, just initialize them as a pair.
369
# Each format describes both the big and little endian layouts (if
370
# useful).
371
 
372
v:int:float_bit:::8 * sizeof (float):4*TARGET_CHAR_BIT::0
373
v:const struct floatformat **:float_format:::::floatformats_ieee_single::pformat (gdbarch->float_format)
374
v:int:double_bit:::8 * sizeof (double):8*TARGET_CHAR_BIT::0
375
v:const struct floatformat **:double_format:::::floatformats_ieee_double::pformat (gdbarch->double_format)
376
v:int:long_double_bit:::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
377
v:const struct floatformat **:long_double_format:::::floatformats_ieee_double::pformat (gdbarch->long_double_format)
378
 
379
# For most targets, a pointer on the target and its representation as an
380
# address in GDB have the same size and "look the same".  For such a
381
# target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
382
# / addr_bit will be set from it.
383
#
384
# If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
385
# also need to set gdbarch_pointer_to_address and gdbarch_address_to_pointer
386
# as well.
387
#
388
# ptr_bit is the size of a pointer on the target
389
v:int:ptr_bit:::8 * sizeof (void*):gdbarch->int_bit::0
390
# addr_bit is the size of a target address as represented in gdb
391
v:int:addr_bit:::8 * sizeof (void*):0:gdbarch_ptr_bit (gdbarch):
392
#
393
# One if \`char' acts like \`signed char', zero if \`unsigned char'.
394
v:int:char_signed:::1:-1:1
395
#
396
F:CORE_ADDR:read_pc:struct regcache *regcache:regcache
397
F:void:write_pc:struct regcache *regcache, CORE_ADDR val:regcache, val
398
# Function for getting target's idea of a frame pointer.  FIXME: GDB's
399
# whole scheme for dealing with "frames" and "frame pointers" needs a
400
# serious shakedown.
401
m:void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset:0:legacy_virtual_frame_pointer::0
402
#
403
M:void:pseudo_register_read:struct regcache *regcache, int cookednum, gdb_byte *buf:regcache, cookednum, buf
404
M:void:pseudo_register_write:struct regcache *regcache, int cookednum, const gdb_byte *buf:regcache, cookednum, buf
405
#
406
v:int:num_regs:::0:-1
407
# This macro gives the number of pseudo-registers that live in the
408
# register namespace but do not get fetched or stored on the target.
409
# These pseudo-registers may be aliases for other registers,
410
# combinations of other registers, or they may be computed by GDB.
411
v:int:num_pseudo_regs:::0:0::0
412
 
413
# GDB's standard (or well known) register numbers.  These can map onto
414
# a real register or a pseudo (computed) register or not be defined at
415
# all (-1).
416
# gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
417
v:int:sp_regnum:::-1:-1::0
418
v:int:pc_regnum:::-1:-1::0
419
v:int:ps_regnum:::-1:-1::0
420
v:int:fp0_regnum:::0:-1::0
421
# Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
422
m:int:stab_reg_to_regnum:int stab_regnr:stab_regnr::no_op_reg_to_regnum::0
423
# Provide a default mapping from a ecoff register number to a gdb REGNUM.
424
m:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr::no_op_reg_to_regnum::0
425
# Convert from an sdb register number to an internal gdb register number.
426
m:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr::no_op_reg_to_regnum::0
427
# Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
428
m:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr::no_op_reg_to_regnum::0
429
m:const char *:register_name:int regnr:regnr::0
430
 
431
# Return the type of a register specified by the architecture.  Only
432
# the register cache should call this function directly; others should
433
# use "register_type".
434
M:struct type *:register_type:int reg_nr:reg_nr
435
 
436
# See gdbint.texinfo, and PUSH_DUMMY_CALL.
437
M:struct frame_id:dummy_id:struct frame_info *this_frame:this_frame
438
# Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
439
# deprecated_fp_regnum.
440
v:int:deprecated_fp_regnum:::-1:-1::0
441
 
442
# See gdbint.texinfo.  See infcall.c.
443
M:CORE_ADDR:push_dummy_call:struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr
444
v:int:call_dummy_location::::AT_ENTRY_POINT::0
445
M: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
446
 
447
m: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
448
M:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
449
M:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
450
# MAP a GDB RAW register number onto a simulator register number.  See
451
# also include/...-sim.h.
452
m:int:register_sim_regno:int reg_nr:reg_nr::legacy_register_sim_regno::0
453
m:int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0
454
m:int:cannot_store_register:int regnum:regnum::cannot_register_not::0
455
# setjmp/longjmp support.
456
F:int:get_longjmp_target:struct frame_info *frame, CORE_ADDR *pc:frame, pc
457
#
458
v:int:believe_pcc_promotion:::::::
459
#
460
m:int:convert_register_p:int regnum, struct type *type:regnum, type:0:generic_convert_register_p::0
461
f:void:register_to_value:struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf:frame, regnum, type, buf:0
462
f:void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf:frame, regnum, type, buf:0
463
# Construct a value representing the contents of register REGNUM in
464
# frame FRAME, interpreted as type TYPE.  The routine needs to
465
# allocate and return a struct value with all value attributes
466
# (but not the value contents) filled in.
467
f:struct value *:value_from_register:struct type *type, int regnum, struct frame_info *frame:type, regnum, frame::default_value_from_register::0
468
#
469
m:CORE_ADDR:pointer_to_address:struct type *type, const gdb_byte *buf:type, buf::unsigned_pointer_to_address::0
470
m:void:address_to_pointer:struct type *type, gdb_byte *buf, CORE_ADDR addr:type, buf, addr::unsigned_address_to_pointer::0
471
M:CORE_ADDR:integer_to_address:struct type *type, const gdb_byte *buf:type, buf
472
 
473
# Return the return-value convention that will be used by FUNCTYPE
474
# to return a value of type VALTYPE.  FUNCTYPE may be NULL in which
475
# case the return convention is computed based only on VALTYPE.
476
#
477
# If READBUF is not NULL, extract the return value and save it in this buffer.
478
#
479
# If WRITEBUF is not NULL, it contains a return value which will be
480
# stored into the appropriate register.  This can be used when we want
481
# to force the value returned by a function (see the "return" command
482
# for instance).
483
M:enum return_value_convention:return_value:struct type *functype, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf:functype, valtype, regcache, readbuf, writebuf
484
 
485
m:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip:0:0
486
M:CORE_ADDR:skip_main_prologue:CORE_ADDR ip:ip
487
f:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0
488
m:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:
489
# Return the adjusted address and kind to use for Z0/Z1 packets.
490
# KIND is usually the memory length of the breakpoint, but may have a
491
# different target-specific meaning.
492
m:void:remote_breakpoint_from_pc:CORE_ADDR *pcptr, int *kindptr:pcptr, kindptr:0:default_remote_breakpoint_from_pc::0
493
M:CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
494
m:int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0
495
m:int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0
496
v:CORE_ADDR:decr_pc_after_break:::0:::0
497
 
498
# A function can be addressed by either it's "pointer" (possibly a
499
# descriptor address) or "entry point" (first executable instruction).
500
# The method "convert_from_func_ptr_addr" converting the former to the
501
# latter.  gdbarch_deprecated_function_start_offset is being used to implement
502
# a simplified subset of that functionality - the function's address
503
# corresponds to the "function pointer" and the function's start
504
# corresponds to the "function entry point" - and hence is redundant.
505
 
506
v:CORE_ADDR:deprecated_function_start_offset:::0:::0
507
 
508
# Return the remote protocol register number associated with this
509
# register.  Normally the identity mapping.
510
m:int:remote_register_number:int regno:regno::default_remote_register_number::0
511
 
512
# Fetch the target specific address used to represent a load module.
513
F:CORE_ADDR:fetch_tls_load_module_address:struct objfile *objfile:objfile
514
#
515
v:CORE_ADDR:frame_args_skip:::0:::0
516
M:CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame
517
M:CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame
518
# DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
519
# frame-base.  Enable frame-base before frame-unwind.
520
F:int:frame_num_args:struct frame_info *frame:frame
521
#
522
M:CORE_ADDR:frame_align:CORE_ADDR address:address
523
m:int:stabs_argument_has_addr:struct type *type:type::default_stabs_argument_has_addr::0
524
v:int:frame_red_zone_size
525
#
526
m:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr, struct target_ops *targ:addr, targ::convert_from_func_ptr_addr_identity::0
527
# On some machines there are bits in addresses which are not really
528
# part of the address, but are used by the kernel, the hardware, etc.
529
# for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
530
# we get a "real" address such as one would find in a symbol table.
531
# This is used only for addresses of instructions, and even then I'm
532
# not sure it's used in all contexts.  It exists to deal with there
533
# being a few stray bits in the PC which would mislead us, not as some
534
# sort of generic thing to handle alignment or segmentation (it's
535
# possible it should be in TARGET_READ_PC instead).
536
m:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr::core_addr_identity::0
537
# It is not at all clear why gdbarch_smash_text_address is not folded into
538
# gdbarch_addr_bits_remove.
539
m:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr::core_addr_identity::0
540
 
541
# FIXME/cagney/2001-01-18: This should be split in two.  A target method that
542
# indicates if the target needs software single step.  An ISA method to
543
# implement it.
544
#
545
# FIXME/cagney/2001-01-18: This should be replaced with something that inserts
546
# breakpoints using the breakpoint system instead of blatting memory directly
547
# (as with rs6000).
548
#
549
# FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
550
# target can single step.  If not, then implement single step using breakpoints.
551
#
552
# A return value of 1 means that the software_single_step breakpoints
553
# were inserted; 0 means they were not.
554
F:int:software_single_step:struct frame_info *frame:frame
555
 
556
# Return non-zero if the processor is executing a delay slot and a
557
# further single-step is needed before the instruction finishes.
558
M:int:single_step_through_delay:struct frame_info *frame:frame
559
# FIXME: cagney/2003-08-28: Need to find a better way of selecting the
560
# disassembler.  Perhaps objdump can handle it?
561
f:int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info::0:
562
f:CORE_ADDR:skip_trampoline_code:struct frame_info *frame, CORE_ADDR pc:frame, pc::generic_skip_trampoline_code::0
563
 
564
 
565
# If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
566
# evaluates non-zero, this is the address where the debugger will place
567
# a step-resume breakpoint to get us past the dynamic linker.
568
m:CORE_ADDR:skip_solib_resolver:CORE_ADDR pc:pc::generic_skip_solib_resolver::0
569
# Some systems also have trampoline code for returning from shared libs.
570
m:int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name::generic_in_solib_return_trampoline::0
571
 
572
# A target might have problems with watchpoints as soon as the stack
573
# frame of the current function has been destroyed.  This mostly happens
574
# as the first action in a funtion's epilogue.  in_function_epilogue_p()
575
# is defined to return a non-zero value if either the given addr is one
576
# instruction after the stack destroying instruction up to the trailing
577
# return instruction or if we can figure out that the stack frame has
578
# already been invalidated regardless of the value of addr.  Targets
579
# which don't suffer from that problem could just let this functionality
580
# untouched.
581
m:int:in_function_epilogue_p:CORE_ADDR addr:addr:0:generic_in_function_epilogue_p::0
582
f:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym::default_elf_make_msymbol_special::0
583
f:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym::default_coff_make_msymbol_special::0
584
v:int:cannot_step_breakpoint:::0:0::0
585
v:int:have_nonsteppable_watchpoint:::0:0::0
586
F:int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class
587
M:const char *:address_class_type_flags_to_name:int type_flags:type_flags
588
M:int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr
589
# Is a register in a group
590
m:int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup::default_register_reggroup_p::0
591
# Fetch the pointer to the ith function argument.
592
F:CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type
593
 
594
# Return the appropriate register set for a core file section with
595
# name SECT_NAME and size SECT_SIZE.
596
M:const struct regset *:regset_from_core_section:const char *sect_name, size_t sect_size:sect_name, sect_size
597
 
598
# When creating core dumps, some systems encode the PID in addition
599
# to the LWP id in core file register section names.  In those cases, the
600
# "XXX" in ".reg/XXX" is encoded as [LWPID << 16 | PID].  This setting
601
# is set to true for such architectures; false if "XXX" represents an LWP
602
# or thread id with no special encoding.
603
v:int:core_reg_section_encodes_pid:::0:0::0
604
 
605
# Supported register notes in a core file.
606
v:struct core_regset_section *:core_regset_sections:const char *name, int len::::::host_address_to_string (gdbarch->core_regset_sections)
607
 
608
# Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
609
# core file into buffer READBUF with length LEN.
610
M:LONGEST:core_xfer_shared_libraries:gdb_byte *readbuf, ULONGEST offset, LONGEST len:readbuf, offset, len
611
 
612
# How the core_stratum layer converts a PTID from a core file to a
613
# string.
614
M:char *:core_pid_to_str:ptid_t ptid:ptid
615
 
616
# BFD target to use when generating a core file.
617
V:const char *:gcore_bfd_target:::0:0:::gdbarch->gcore_bfd_target
618
 
619
# If the elements of C++ vtables are in-place function descriptors rather
620
# than normal function pointers (which may point to code or a descriptor),
621
# set this to one.
622
v:int:vtable_function_descriptors:::0:0::0
623
 
624
# Set if the least significant bit of the delta is used instead of the least
625
# significant bit of the pfn for pointers to virtual member functions.
626
v:int:vbit_in_delta:::0:0::0
627
 
628
# Advance PC to next instruction in order to skip a permanent breakpoint.
629
F:void:skip_permanent_breakpoint:struct regcache *regcache:regcache
630
 
631
# The maximum length of an instruction on this architecture.
632
V:ULONGEST:max_insn_length:::0:0
633
 
634
# Copy the instruction at FROM to TO, and make any adjustments
635
# necessary to single-step it at that address.
636
#
637
# REGS holds the state the thread's registers will have before
638
# executing the copied instruction; the PC in REGS will refer to FROM,
639
# not the copy at TO.  The caller should update it to point at TO later.
640
#
641
# Return a pointer to data of the architecture's choice to be passed
642
# to gdbarch_displaced_step_fixup.  Or, return NULL to indicate that
643
# the instruction's effects have been completely simulated, with the
644
# resulting state written back to REGS.
645
#
646
# For a general explanation of displaced stepping and how GDB uses it,
647
# see the comments in infrun.c.
648
#
649
# The TO area is only guaranteed to have space for
650
# gdbarch_max_insn_length (arch) bytes, so this function must not
651
# write more bytes than that to that area.
652
#
653
# If you do not provide this function, GDB assumes that the
654
# architecture does not support displaced stepping.
655
#
656
# If your architecture doesn't need to adjust instructions before
657
# single-stepping them, consider using simple_displaced_step_copy_insn
658
# here.
659
M:struct displaced_step_closure *:displaced_step_copy_insn:CORE_ADDR from, CORE_ADDR to, struct regcache *regs:from, to, regs
660
 
661
# Return true if GDB should use hardware single-stepping to execute
662
# the displaced instruction identified by CLOSURE.  If false,
663
# GDB will simply restart execution at the displaced instruction
664
# location, and it is up to the target to ensure GDB will receive
665
# control again (e.g. by placing a software breakpoint instruction
666
# into the displaced instruction buffer).
667
#
668
# The default implementation returns false on all targets that
669
# provide a gdbarch_software_single_step routine, and true otherwise.
670
m:int:displaced_step_hw_singlestep:struct displaced_step_closure *closure:closure::default_displaced_step_hw_singlestep::0
671
 
672
# Fix up the state resulting from successfully single-stepping a
673
# displaced instruction, to give the result we would have gotten from
674
# stepping the instruction in its original location.
675
#
676
# REGS is the register state resulting from single-stepping the
677
# displaced instruction.
678
#
679
# CLOSURE is the result from the matching call to
680
# gdbarch_displaced_step_copy_insn.
681
#
682
# If you provide gdbarch_displaced_step_copy_insn.but not this
683
# function, then GDB assumes that no fixup is needed after
684
# single-stepping the instruction.
685
#
686
# For a general explanation of displaced stepping and how GDB uses it,
687
# see the comments in infrun.c.
688
M:void:displaced_step_fixup:struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs:closure, from, to, regs::NULL
689
 
690
# Free a closure returned by gdbarch_displaced_step_copy_insn.
691
#
692
# If you provide gdbarch_displaced_step_copy_insn, you must provide
693
# this function as well.
694
#
695
# If your architecture uses closures that don't need to be freed, then
696
# you can use simple_displaced_step_free_closure here.
697
#
698
# For a general explanation of displaced stepping and how GDB uses it,
699
# see the comments in infrun.c.
700
m:void:displaced_step_free_closure:struct displaced_step_closure *closure:closure::NULL::(! gdbarch->displaced_step_free_closure) != (! gdbarch->displaced_step_copy_insn)
701
 
702
# Return the address of an appropriate place to put displaced
703
# instructions while we step over them.  There need only be one such
704
# place, since we're only stepping one thread over a breakpoint at a
705
# time.
706
#
707
# For a general explanation of displaced stepping and how GDB uses it,
708
# see the comments in infrun.c.
709
m:CORE_ADDR:displaced_step_location:void:::NULL::(! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn)
710
 
711
# Refresh overlay mapped state for section OSECT.
712
F:void:overlay_update:struct obj_section *osect:osect
713
 
714
M:const struct target_desc *:core_read_description:struct target_ops *target, bfd *abfd:target, abfd
715
 
716
# Handle special encoding of static variables in stabs debug info.
717
F:char *:static_transform_name:char *name:name
718
# Set if the address in N_SO or N_FUN stabs may be zero.
719
v:int:sofun_address_maybe_missing:::0:0::0
720
 
721
# Parse the instruction at ADDR storing in the record execution log
722
# the registers REGCACHE and memory ranges that will be affected when
723
# the instruction executes, along with their current values.
724
# Return -1 if something goes wrong, 0 otherwise.
725
M:int:process_record:struct regcache *regcache, CORE_ADDR addr:regcache, addr
726
 
727
# Save process state after a signal.
728
# Return -1 if something goes wrong, 0 otherwise.
729
M:int:process_record_signal:struct regcache *regcache, enum target_signal signal:regcache, signal
730
 
731
# Signal translation: translate inferior's signal (host's) number into
732
# GDB's representation.
733
m:enum target_signal:target_signal_from_host:int signo:signo::default_target_signal_from_host::0
734
# Signal translation: translate GDB's signal number into inferior's host
735
# signal number.
736
m:int:target_signal_to_host:enum target_signal ts:ts::default_target_signal_to_host::0
737
 
738
# Extra signal info inspection.
739
#
740
# Return a type suitable to inspect extra signal information.
741
M:struct type *:get_siginfo_type:void:
742
 
743
# Record architecture-specific information from the symbol table.
744
M:void:record_special_symbol:struct objfile *objfile, asymbol *sym:objfile, sym
745
 
746
# Function for the 'catch syscall' feature.
747
 
748
# Get architecture-specific system calls information from registers.
749
M:LONGEST:get_syscall_number:ptid_t ptid:ptid
750
 
751
# True if the list of shared libraries is one and only for all
752
# processes, as opposed to a list of shared libraries per inferior.
753
# This usually means that all processes, although may or may not share
754
# an address space, will see the same set of symbols at the same
755
# addresses.
756
v:int:has_global_solist:::0:0::0
757
 
758
# On some targets, even though each inferior has its own private
759
# address space, the debug interface takes care of making breakpoints
760
# visible to all address spaces automatically.  For such cases,
761
# this property should be set to true.
762
v:int:has_global_breakpoints:::0:0::0
763
 
764
# True if inferiors share an address space (e.g., uClinux).
765
m:int:has_shared_address_space:void:::default_has_shared_address_space::0
766
 
767
# True if a fast tracepoint can be set at an address.
768
m:int:fast_tracepoint_valid_at:CORE_ADDR addr, int *isize, char **msg:addr, isize, msg::default_fast_tracepoint_valid_at::0
769
 
770
# Not NULL if a target has additonal field for qSupported.
771
v:const char *:qsupported:::0:0::0:gdbarch->qsupported
772
EOF
773
}
774
 
775
#
776
# The .log file
777
#
778
exec > new-gdbarch.log
779
function_list | while do_read
780
do
781
    cat <<EOF
782
${class} ${returntype} ${function} ($formal)
783
EOF
784
    for r in ${read}
785
    do
786
        eval echo \"\ \ \ \ ${r}=\${${r}}\"
787
    done
788
    if class_is_predicate_p && fallback_default_p
789
    then
790
        echo "Error: predicate function ${function} can not have a non- multi-arch default" 1>&2
791
        kill $$
792
        exit 1
793
    fi
794
    if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
795
    then
796
        echo "Error: postdefault is useless when invalid_p=0" 1>&2
797
        kill $$
798
        exit 1
799
    fi
800
    if class_is_multiarch_p
801
    then
802
        if class_is_predicate_p ; then :
803
        elif test "x${predefault}" = "x"
804
        then
805
            echo "Error: pure multi-arch function ${function} must have a predefault" 1>&2
806
            kill $$
807
            exit 1
808
        fi
809
    fi
810
    echo ""
811
done
812
 
813
exec 1>&2
814
compare_new gdbarch.log
815
 
816
 
817
copyright ()
818
{
819
cat <<EOF
820
/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
821
 
822
/* Dynamic architecture support for GDB, the GNU debugger.
823
 
824
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
825
   2007, 2008, 2009 Free Software Foundation, Inc.
826
 
827
   This file is part of GDB.
828
 
829
   This program is free software; you can redistribute it and/or modify
830
   it under the terms of the GNU General Public License as published by
831
   the Free Software Foundation; either version 3 of the License, or
832
   (at your option) any later version.
833
 
834
   This program is distributed in the hope that it will be useful,
835
   but WITHOUT ANY WARRANTY; without even the implied warranty of
836
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
837
   GNU General Public License for more details.
838
 
839
   You should have received a copy of the GNU General Public License
840
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
841
 
842
/* This file was created with the aid of \`\`gdbarch.sh''.
843
 
844
   The Bourne shell script \`\`gdbarch.sh'' creates the files
845
   \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
846
   against the existing \`\`gdbarch.[hc]''.  Any differences found
847
   being reported.
848
 
849
   If editing this file, please also run gdbarch.sh and merge any
850
   changes into that script. Conversely, when making sweeping changes
851
   to this file, modifying gdbarch.sh and using its output may prove
852
   easier. */
853
 
854
EOF
855
}
856
 
857
#
858
# The .h file
859
#
860
 
861
exec > new-gdbarch.h
862
copyright
863
cat <<EOF
864
#ifndef GDBARCH_H
865
#define GDBARCH_H
866
 
867
struct floatformat;
868
struct ui_file;
869
struct frame_info;
870
struct value;
871
struct objfile;
872
struct obj_section;
873
struct minimal_symbol;
874
struct regcache;
875
struct reggroup;
876
struct regset;
877
struct disassemble_info;
878
struct target_ops;
879
struct obstack;
880
struct bp_target_info;
881
struct target_desc;
882
struct displaced_step_closure;
883
struct core_regset_section;
884
struct syscall;
885
 
886
/* The architecture associated with the connection to the target.
887
 
888
   The architecture vector provides some information that is really
889
   a property of the target: The layout of certain packets, for instance;
890
   or the solib_ops vector.  Etc.  To differentiate architecture accesses
891
   to per-target properties from per-thread/per-frame/per-objfile properties,
892
   accesses to per-target properties should be made through target_gdbarch.
893
 
894
   Eventually, when support for multiple targets is implemented in
895
   GDB, this global should be made target-specific.  */
896
extern struct gdbarch *target_gdbarch;
897
EOF
898
 
899
# function typedef's
900
printf "\n"
901
printf "\n"
902
printf "/* The following are pre-initialized by GDBARCH. */\n"
903
function_list | while do_read
904
do
905
    if class_is_info_p
906
    then
907
        printf "\n"
908
        printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
909
        printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
910
    fi
911
done
912
 
913
# function typedef's
914
printf "\n"
915
printf "\n"
916
printf "/* The following are initialized by the target dependent code. */\n"
917
function_list | while do_read
918
do
919
    if [ -n "${comment}" ]
920
    then
921
        echo "${comment}" | sed \
922
            -e '2 s,#,/*,' \
923
            -e '3,$ s,#,  ,' \
924
            -e '$ s,$, */,'
925
    fi
926
 
927
    if class_is_predicate_p
928
    then
929
        printf "\n"
930
        printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
931
    fi
932
    if class_is_variable_p
933
    then
934
        printf "\n"
935
        printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
936
        printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
937
    fi
938
    if class_is_function_p
939
    then
940
        printf "\n"
941
        if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
942
        then
943
            printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
944
        elif class_is_multiarch_p
945
        then
946
            printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
947
        else
948
            printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
949
        fi
950
        if [ "x${formal}" = "xvoid" ]
951
        then
952
          printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
953
        else
954
          printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
955
        fi
956
        printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
957
    fi
958
done
959
 
960
# close it off
961
cat <<EOF
962
 
963
/* Definition for an unknown syscall, used basically in error-cases.  */
964
#define UNKNOWN_SYSCALL (-1)
965
 
966
extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
967
 
968
 
969
/* Mechanism for co-ordinating the selection of a specific
970
   architecture.
971
 
972
   GDB targets (*-tdep.c) can register an interest in a specific
973
   architecture.  Other GDB components can register a need to maintain
974
   per-architecture data.
975
 
976
   The mechanisms below ensures that there is only a loose connection
977
   between the set-architecture command and the various GDB
978
   components.  Each component can independently register their need
979
   to maintain architecture specific data with gdbarch.
980
 
981
   Pragmatics:
982
 
983
   Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
984
   didn't scale.
985
 
986
   The more traditional mega-struct containing architecture specific
987
   data for all the various GDB components was also considered.  Since
988
   GDB is built from a variable number of (fairly independent)
989
   components it was determined that the global aproach was not
990
   applicable. */
991
 
992
 
993
/* Register a new architectural family with GDB.
994
 
995
   Register support for the specified ARCHITECTURE with GDB.  When
996
   gdbarch determines that the specified architecture has been
997
   selected, the corresponding INIT function is called.
998
 
999
   --
1000
 
1001
   The INIT function takes two parameters: INFO which contains the
1002
   information available to gdbarch about the (possibly new)
1003
   architecture; ARCHES which is a list of the previously created
1004
   \`\`struct gdbarch'' for this architecture.
1005
 
1006
   The INFO parameter is, as far as possible, be pre-initialized with
1007
   information obtained from INFO.ABFD or the global defaults.
1008
 
1009
   The ARCHES parameter is a linked list (sorted most recently used)
1010
   of all the previously created architures for this architecture
1011
   family.  The (possibly NULL) ARCHES->gdbarch can used to access
1012
   values from the previously selected architecture for this
1013
   architecture family.
1014
 
1015
   The INIT function shall return any of: NULL - indicating that it
1016
   doesn't recognize the selected architecture; an existing \`\`struct
1017
   gdbarch'' from the ARCHES list - indicating that the new
1018
   architecture is just a synonym for an earlier architecture (see
1019
   gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1020
   - that describes the selected architecture (see gdbarch_alloc()).
1021
 
1022
   The DUMP_TDEP function shall print out all target specific values.
1023
   Care should be taken to ensure that the function works in both the
1024
   multi-arch and non- multi-arch cases. */
1025
 
1026
struct gdbarch_list
1027
{
1028
  struct gdbarch *gdbarch;
1029
  struct gdbarch_list *next;
1030
};
1031
 
1032
struct gdbarch_info
1033
{
1034
  /* Use default: NULL (ZERO). */
1035
  const struct bfd_arch_info *bfd_arch_info;
1036
 
1037
  /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
1038
  int byte_order;
1039
 
1040
  int byte_order_for_code;
1041
 
1042
  /* Use default: NULL (ZERO). */
1043
  bfd *abfd;
1044
 
1045
  /* Use default: NULL (ZERO). */
1046
  struct gdbarch_tdep_info *tdep_info;
1047
 
1048
  /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
1049
  enum gdb_osabi osabi;
1050
 
1051
  /* Use default: NULL (ZERO).  */
1052
  const struct target_desc *target_desc;
1053
};
1054
 
1055
typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1056
typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1057
 
1058
/* DEPRECATED - use gdbarch_register() */
1059
extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1060
 
1061
extern void gdbarch_register (enum bfd_architecture architecture,
1062
                              gdbarch_init_ftype *,
1063
                              gdbarch_dump_tdep_ftype *);
1064
 
1065
 
1066
/* Return a freshly allocated, NULL terminated, array of the valid
1067
   architecture names.  Since architectures are registered during the
1068
   _initialize phase this function only returns useful information
1069
   once initialization has been completed. */
1070
 
1071
extern const char **gdbarch_printable_names (void);
1072
 
1073
 
1074
/* Helper function.  Search the list of ARCHES for a GDBARCH that
1075
   matches the information provided by INFO. */
1076
 
1077
extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1078
 
1079
 
1080
/* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
1081
   basic initialization using values obtained from the INFO and TDEP
1082
   parameters.  set_gdbarch_*() functions are called to complete the
1083
   initialization of the object. */
1084
 
1085
extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1086
 
1087
 
1088
/* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
1089
   It is assumed that the caller freeds the \`\`struct
1090
   gdbarch_tdep''. */
1091
 
1092
extern void gdbarch_free (struct gdbarch *);
1093
 
1094
 
1095
/* Helper function.  Allocate memory from the \`\`struct gdbarch''
1096
   obstack.  The memory is freed when the corresponding architecture
1097
   is also freed.  */
1098
 
1099
extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1100
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1101
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1102
 
1103
 
1104
/* Helper function. Force an update of the current architecture.
1105
 
1106
   The actual architecture selected is determined by INFO, \`\`(gdb) set
1107
   architecture'' et.al., the existing architecture and BFD's default
1108
   architecture.  INFO should be initialized to zero and then selected
1109
   fields should be updated.
1110
 
1111
   Returns non-zero if the update succeeds */
1112
 
1113
extern int gdbarch_update_p (struct gdbarch_info info);
1114
 
1115
 
1116
/* Helper function.  Find an architecture matching info.
1117
 
1118
   INFO should be initialized using gdbarch_info_init, relevant fields
1119
   set, and then finished using gdbarch_info_fill.
1120
 
1121
   Returns the corresponding architecture, or NULL if no matching
1122
   architecture was found.  */
1123
 
1124
extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1125
 
1126
 
1127
/* Helper function.  Set the global "target_gdbarch" to "gdbarch".
1128
 
1129
   FIXME: kettenis/20031124: Of the functions that follow, only
1130
   gdbarch_from_bfd is supposed to survive.  The others will
1131
   dissappear since in the future GDB will (hopefully) be truly
1132
   multi-arch.  However, for now we're still stuck with the concept of
1133
   a single active architecture.  */
1134
 
1135
extern void deprecated_target_gdbarch_select_hack (struct gdbarch *gdbarch);
1136
 
1137
 
1138
/* Register per-architecture data-pointer.
1139
 
1140
   Reserve space for a per-architecture data-pointer.  An identifier
1141
   for the reserved data-pointer is returned.  That identifer should
1142
   be saved in a local static variable.
1143
 
1144
   Memory for the per-architecture data shall be allocated using
1145
   gdbarch_obstack_zalloc.  That memory will be deleted when the
1146
   corresponding architecture object is deleted.
1147
 
1148
   When a previously created architecture is re-selected, the
1149
   per-architecture data-pointer for that previous architecture is
1150
   restored.  INIT() is not re-called.
1151
 
1152
   Multiple registrarants for any architecture are allowed (and
1153
   strongly encouraged).  */
1154
 
1155
struct gdbarch_data;
1156
 
1157
typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1158
extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1159
typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1160
extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1161
extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1162
                                         struct gdbarch_data *data,
1163
                                         void *pointer);
1164
 
1165
extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1166
 
1167
 
1168
/* Set the dynamic target-system-dependent parameters (architecture,
1169
   byte-order, ...) using information found in the BFD */
1170
 
1171
extern void set_gdbarch_from_file (bfd *);
1172
 
1173
 
1174
/* Initialize the current architecture to the "first" one we find on
1175
   our list.  */
1176
 
1177
extern void initialize_current_architecture (void);
1178
 
1179
/* gdbarch trace variable */
1180
extern int gdbarch_debug;
1181
 
1182
extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1183
 
1184
#endif
1185
EOF
1186
exec 1>&2
1187
#../move-if-change new-gdbarch.h gdbarch.h
1188
compare_new gdbarch.h
1189
 
1190
 
1191
#
1192
# C file
1193
#
1194
 
1195
exec > new-gdbarch.c
1196
copyright
1197
cat <<EOF
1198
 
1199
#include "defs.h"
1200
#include "arch-utils.h"
1201
 
1202
#include "gdbcmd.h"
1203
#include "inferior.h"
1204
#include "symcat.h"
1205
 
1206
#include "floatformat.h"
1207
 
1208
#include "gdb_assert.h"
1209
#include "gdb_string.h"
1210
#include "reggroups.h"
1211
#include "osabi.h"
1212
#include "gdb_obstack.h"
1213
#include "observer.h"
1214
#include "regcache.h"
1215
 
1216
/* Static function declarations */
1217
 
1218
static void alloc_gdbarch_data (struct gdbarch *);
1219
 
1220
/* Non-zero if we want to trace architecture code.  */
1221
 
1222
#ifndef GDBARCH_DEBUG
1223
#define GDBARCH_DEBUG 0
1224
#endif
1225
int gdbarch_debug = GDBARCH_DEBUG;
1226
static void
1227
show_gdbarch_debug (struct ui_file *file, int from_tty,
1228
                    struct cmd_list_element *c, const char *value)
1229
{
1230
  fprintf_filtered (file, _("Architecture debugging is %s.\\n"), value);
1231
}
1232
 
1233
static const char *
1234
pformat (const struct floatformat **format)
1235
{
1236
  if (format == NULL)
1237
    return "(null)";
1238
  else
1239
    /* Just print out one of them - this is only for diagnostics.  */
1240
    return format[0]->name;
1241
}
1242
 
1243
EOF
1244
 
1245
# gdbarch open the gdbarch object
1246
printf "\n"
1247
printf "/* Maintain the struct gdbarch object */\n"
1248
printf "\n"
1249
printf "struct gdbarch\n"
1250
printf "{\n"
1251
printf "  /* Has this architecture been fully initialized?  */\n"
1252
printf "  int initialized_p;\n"
1253
printf "\n"
1254
printf "  /* An obstack bound to the lifetime of the architecture.  */\n"
1255
printf "  struct obstack *obstack;\n"
1256
printf "\n"
1257
printf "  /* basic architectural information */\n"
1258
function_list | while do_read
1259
do
1260
    if class_is_info_p
1261
    then
1262
        printf "  ${returntype} ${function};\n"
1263
    fi
1264
done
1265
printf "\n"
1266
printf "  /* target specific vector. */\n"
1267
printf "  struct gdbarch_tdep *tdep;\n"
1268
printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
1269
printf "\n"
1270
printf "  /* per-architecture data-pointers */\n"
1271
printf "  unsigned nr_data;\n"
1272
printf "  void **data;\n"
1273
printf "\n"
1274
printf "  /* per-architecture swap-regions */\n"
1275
printf "  struct gdbarch_swap *swap;\n"
1276
printf "\n"
1277
cat <<EOF
1278
  /* Multi-arch values.
1279
 
1280
     When extending this structure you must:
1281
 
1282
     Add the field below.
1283
 
1284
     Declare set/get functions and define the corresponding
1285
     macro in gdbarch.h.
1286
 
1287
     gdbarch_alloc(): If zero/NULL is not a suitable default,
1288
     initialize the new field.
1289
 
1290
     verify_gdbarch(): Confirm that the target updated the field
1291
     correctly.
1292
 
1293
     gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1294
     field is dumped out
1295
 
1296
     \`\`startup_gdbarch()'': Append an initial value to the static
1297
     variable (base values on the host's c-type system).
1298
 
1299
     get_gdbarch(): Implement the set/get functions (probably using
1300
     the macro's as shortcuts).
1301
 
1302
     */
1303
 
1304
EOF
1305
function_list | while do_read
1306
do
1307
    if class_is_variable_p
1308
    then
1309
        printf "  ${returntype} ${function};\n"
1310
    elif class_is_function_p
1311
    then
1312
        printf "  gdbarch_${function}_ftype *${function};\n"
1313
    fi
1314
done
1315
printf "};\n"
1316
 
1317
# A pre-initialized vector
1318
printf "\n"
1319
printf "\n"
1320
cat <<EOF
1321
/* The default architecture uses host values (for want of a better
1322
   choice). */
1323
EOF
1324
printf "\n"
1325
printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1326
printf "\n"
1327
printf "struct gdbarch startup_gdbarch =\n"
1328
printf "{\n"
1329
printf "  1, /* Always initialized.  */\n"
1330
printf "  NULL, /* The obstack.  */\n"
1331
printf "  /* basic architecture information */\n"
1332
function_list | while do_read
1333
do
1334
    if class_is_info_p
1335
    then
1336
        printf "  ${staticdefault},  /* ${function} */\n"
1337
    fi
1338
done
1339
cat <<EOF
1340
  /* target specific vector and its dump routine */
1341
  NULL, NULL,
1342
  /*per-architecture data-pointers and swap regions */
1343
  0, NULL, NULL,
1344
  /* Multi-arch values */
1345
EOF
1346
function_list | while do_read
1347
do
1348
    if class_is_function_p || class_is_variable_p
1349
    then
1350
        printf "  ${staticdefault},  /* ${function} */\n"
1351
    fi
1352
done
1353
cat <<EOF
1354
  /* startup_gdbarch() */
1355
};
1356
 
1357
struct gdbarch *target_gdbarch = &startup_gdbarch;
1358
EOF
1359
 
1360
# Create a new gdbarch struct
1361
cat <<EOF
1362
 
1363
/* Create a new \`\`struct gdbarch'' based on information provided by
1364
   \`\`struct gdbarch_info''. */
1365
EOF
1366
printf "\n"
1367
cat <<EOF
1368
struct gdbarch *
1369
gdbarch_alloc (const struct gdbarch_info *info,
1370
               struct gdbarch_tdep *tdep)
1371
{
1372
  struct gdbarch *gdbarch;
1373
 
1374
  /* Create an obstack for allocating all the per-architecture memory,
1375
     then use that to allocate the architecture vector.  */
1376
  struct obstack *obstack = XMALLOC (struct obstack);
1377
  obstack_init (obstack);
1378
  gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
1379
  memset (gdbarch, 0, sizeof (*gdbarch));
1380
  gdbarch->obstack = obstack;
1381
 
1382
  alloc_gdbarch_data (gdbarch);
1383
 
1384
  gdbarch->tdep = tdep;
1385
EOF
1386
printf "\n"
1387
function_list | while do_read
1388
do
1389
    if class_is_info_p
1390
    then
1391
        printf "  gdbarch->${function} = info->${function};\n"
1392
    fi
1393
done
1394
printf "\n"
1395
printf "  /* Force the explicit initialization of these. */\n"
1396
function_list | while do_read
1397
do
1398
    if class_is_function_p || class_is_variable_p
1399
    then
1400
        if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1401
        then
1402
          printf "  gdbarch->${function} = ${predefault};\n"
1403
        fi
1404
    fi
1405
done
1406
cat <<EOF
1407
  /* gdbarch_alloc() */
1408
 
1409
  return gdbarch;
1410
}
1411
EOF
1412
 
1413
# Free a gdbarch struct.
1414
printf "\n"
1415
printf "\n"
1416
cat <<EOF
1417
/* Allocate extra space using the per-architecture obstack.  */
1418
 
1419
void *
1420
gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
1421
{
1422
  void *data = obstack_alloc (arch->obstack, size);
1423
  memset (data, 0, size);
1424
  return data;
1425
}
1426
 
1427
 
1428
/* Free a gdbarch struct.  This should never happen in normal
1429
   operation --- once you've created a gdbarch, you keep it around.
1430
   However, if an architecture's init function encounters an error
1431
   building the structure, it may need to clean up a partially
1432
   constructed gdbarch.  */
1433
 
1434
void
1435
gdbarch_free (struct gdbarch *arch)
1436
{
1437
  struct obstack *obstack;
1438
  gdb_assert (arch != NULL);
1439
  gdb_assert (!arch->initialized_p);
1440
  obstack = arch->obstack;
1441
  obstack_free (obstack, 0); /* Includes the ARCH.  */
1442
  xfree (obstack);
1443
}
1444
EOF
1445
 
1446
# verify a new architecture
1447
cat <<EOF
1448
 
1449
 
1450
/* Ensure that all values in a GDBARCH are reasonable.  */
1451
 
1452
static void
1453
verify_gdbarch (struct gdbarch *gdbarch)
1454
{
1455
  struct ui_file *log;
1456
  struct cleanup *cleanups;
1457
  long length;
1458
  char *buf;
1459
  log = mem_fileopen ();
1460
  cleanups = make_cleanup_ui_file_delete (log);
1461
  /* fundamental */
1462
  if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1463
    fprintf_unfiltered (log, "\n\tbyte-order");
1464
  if (gdbarch->bfd_arch_info == NULL)
1465
    fprintf_unfiltered (log, "\n\tbfd_arch_info");
1466
  /* Check those that need to be defined for the given multi-arch level. */
1467
EOF
1468
function_list | while do_read
1469
do
1470
    if class_is_function_p || class_is_variable_p
1471
    then
1472
        if [ "x${invalid_p}" = "x0" ]
1473
        then
1474
            printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1475
        elif class_is_predicate_p
1476
        then
1477
            printf "  /* Skip verify of ${function}, has predicate */\n"
1478
        # FIXME: See do_read for potential simplification
1479
        elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1480
        then
1481
            printf "  if (${invalid_p})\n"
1482
            printf "    gdbarch->${function} = ${postdefault};\n"
1483
        elif [ -n "${predefault}" -a -n "${postdefault}" ]
1484
        then
1485
            printf "  if (gdbarch->${function} == ${predefault})\n"
1486
            printf "    gdbarch->${function} = ${postdefault};\n"
1487
        elif [ -n "${postdefault}" ]
1488
        then
1489
            printf "  if (gdbarch->${function} == 0)\n"
1490
            printf "    gdbarch->${function} = ${postdefault};\n"
1491
        elif [ -n "${invalid_p}" ]
1492
        then
1493
            printf "  if (${invalid_p})\n"
1494
            printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1495
        elif [ -n "${predefault}" ]
1496
        then
1497
            printf "  if (gdbarch->${function} == ${predefault})\n"
1498
            printf "    fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1499
        fi
1500
    fi
1501
done
1502
cat <<EOF
1503
  buf = ui_file_xstrdup (log, &length);
1504
  make_cleanup (xfree, buf);
1505
  if (length > 0)
1506
    internal_error (__FILE__, __LINE__,
1507
                    _("verify_gdbarch: the following are invalid ...%s"),
1508
                    buf);
1509
  do_cleanups (cleanups);
1510
}
1511
EOF
1512
 
1513
# dump the structure
1514
printf "\n"
1515
printf "\n"
1516
cat <<EOF
1517
/* Print out the details of the current architecture. */
1518
 
1519
void
1520
gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1521
{
1522
  const char *gdb_nm_file = "<not-defined>";
1523
#if defined (GDB_NM_FILE)
1524
  gdb_nm_file = GDB_NM_FILE;
1525
#endif
1526
  fprintf_unfiltered (file,
1527
                      "gdbarch_dump: GDB_NM_FILE = %s\\n",
1528
                      gdb_nm_file);
1529
EOF
1530
function_list | sort -t: -k 3 | while do_read
1531
do
1532
    # First the predicate
1533
    if class_is_predicate_p
1534
    then
1535
        printf "  fprintf_unfiltered (file,\n"
1536
        printf "                      \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
1537
        printf "                      gdbarch_${function}_p (gdbarch));\n"
1538
    fi
1539
    # Print the corresponding value.
1540
    if class_is_function_p
1541
    then
1542
        printf "  fprintf_unfiltered (file,\n"
1543
        printf "                      \"gdbarch_dump: ${function} = <%%s>\\\\n\",\n"
1544
        printf "                      host_address_to_string (gdbarch->${function}));\n"
1545
    else
1546
        # It is a variable
1547
        case "${print}:${returntype}" in
1548
            :CORE_ADDR )
1549
                fmt="%s"
1550
                print="core_addr_to_string_nz (gdbarch->${function})"
1551
                ;;
1552
            :* )
1553
                fmt="%s"
1554
                print="plongest (gdbarch->${function})"
1555
                ;;
1556
            * )
1557
                fmt="%s"
1558
                ;;
1559
        esac
1560
        printf "  fprintf_unfiltered (file,\n"
1561
        printf "                      \"gdbarch_dump: ${function} = %s\\\\n\",\n" "${fmt}"
1562
        printf "                      ${print});\n"
1563
    fi
1564
done
1565
cat <<EOF
1566
  if (gdbarch->dump_tdep != NULL)
1567
    gdbarch->dump_tdep (gdbarch, file);
1568
}
1569
EOF
1570
 
1571
 
1572
# GET/SET
1573
printf "\n"
1574
cat <<EOF
1575
struct gdbarch_tdep *
1576
gdbarch_tdep (struct gdbarch *gdbarch)
1577
{
1578
  if (gdbarch_debug >= 2)
1579
    fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1580
  return gdbarch->tdep;
1581
}
1582
EOF
1583
printf "\n"
1584
function_list | while do_read
1585
do
1586
    if class_is_predicate_p
1587
    then
1588
        printf "\n"
1589
        printf "int\n"
1590
        printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1591
        printf "{\n"
1592
        printf "  gdb_assert (gdbarch != NULL);\n"
1593
        printf "  return ${predicate};\n"
1594
        printf "}\n"
1595
    fi
1596
    if class_is_function_p
1597
    then
1598
        printf "\n"
1599
        printf "${returntype}\n"
1600
        if [ "x${formal}" = "xvoid" ]
1601
        then
1602
          printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1603
        else
1604
          printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1605
        fi
1606
        printf "{\n"
1607
        printf "  gdb_assert (gdbarch != NULL);\n"
1608
        printf "  gdb_assert (gdbarch->${function} != NULL);\n"
1609
        if class_is_predicate_p && test -n "${predefault}"
1610
        then
1611
            # Allow a call to a function with a predicate.
1612
            printf "  /* Do not check predicate: ${predicate}, allow call.  */\n"
1613
        fi
1614
        printf "  if (gdbarch_debug >= 2)\n"
1615
        printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1616
        if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1617
        then
1618
            if class_is_multiarch_p
1619
            then
1620
                params="gdbarch"
1621
            else
1622
                params=""
1623
            fi
1624
        else
1625
            if class_is_multiarch_p
1626
            then
1627
                params="gdbarch, ${actual}"
1628
            else
1629
                params="${actual}"
1630
            fi
1631
        fi
1632
        if [ "x${returntype}" = "xvoid" ]
1633
        then
1634
          printf "  gdbarch->${function} (${params});\n"
1635
        else
1636
          printf "  return gdbarch->${function} (${params});\n"
1637
        fi
1638
        printf "}\n"
1639
        printf "\n"
1640
        printf "void\n"
1641
        printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1642
        printf "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})\n"
1643
        printf "{\n"
1644
        printf "  gdbarch->${function} = ${function};\n"
1645
        printf "}\n"
1646
    elif class_is_variable_p
1647
    then
1648
        printf "\n"
1649
        printf "${returntype}\n"
1650
        printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1651
        printf "{\n"
1652
        printf "  gdb_assert (gdbarch != NULL);\n"
1653
        if [ "x${invalid_p}" = "x0" ]
1654
        then
1655
            printf "  /* Skip verify of ${function}, invalid_p == 0 */\n"
1656
        elif [ -n "${invalid_p}" ]
1657
        then
1658
            printf "  /* Check variable is valid.  */\n"
1659
            printf "  gdb_assert (!(${invalid_p}));\n"
1660
        elif [ -n "${predefault}" ]
1661
        then
1662
            printf "  /* Check variable changed from pre-default.  */\n"
1663
            printf "  gdb_assert (gdbarch->${function} != ${predefault});\n"
1664
        fi
1665
        printf "  if (gdbarch_debug >= 2)\n"
1666
        printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1667
        printf "  return gdbarch->${function};\n"
1668
        printf "}\n"
1669
        printf "\n"
1670
        printf "void\n"
1671
        printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1672
        printf "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})\n"
1673
        printf "{\n"
1674
        printf "  gdbarch->${function} = ${function};\n"
1675
        printf "}\n"
1676
    elif class_is_info_p
1677
    then
1678
        printf "\n"
1679
        printf "${returntype}\n"
1680
        printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1681
        printf "{\n"
1682
        printf "  gdb_assert (gdbarch != NULL);\n"
1683
        printf "  if (gdbarch_debug >= 2)\n"
1684
        printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1685
        printf "  return gdbarch->${function};\n"
1686
        printf "}\n"
1687
    fi
1688
done
1689
 
1690
# All the trailing guff
1691
cat <<EOF
1692
 
1693
 
1694
/* Keep a registry of per-architecture data-pointers required by GDB
1695
   modules. */
1696
 
1697
struct gdbarch_data
1698
{
1699
  unsigned index;
1700
  int init_p;
1701
  gdbarch_data_pre_init_ftype *pre_init;
1702
  gdbarch_data_post_init_ftype *post_init;
1703
};
1704
 
1705
struct gdbarch_data_registration
1706
{
1707
  struct gdbarch_data *data;
1708
  struct gdbarch_data_registration *next;
1709
};
1710
 
1711
struct gdbarch_data_registry
1712
{
1713
  unsigned nr;
1714
  struct gdbarch_data_registration *registrations;
1715
};
1716
 
1717
struct gdbarch_data_registry gdbarch_data_registry =
1718
{
1719
  0, NULL,
1720
};
1721
 
1722
static struct gdbarch_data *
1723
gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
1724
                       gdbarch_data_post_init_ftype *post_init)
1725
{
1726
  struct gdbarch_data_registration **curr;
1727
  /* Append the new registraration.  */
1728
  for (curr = &gdbarch_data_registry.registrations;
1729
       (*curr) != NULL;
1730
       curr = &(*curr)->next);
1731
  (*curr) = XMALLOC (struct gdbarch_data_registration);
1732
  (*curr)->next = NULL;
1733
  (*curr)->data = XMALLOC (struct gdbarch_data);
1734
  (*curr)->data->index = gdbarch_data_registry.nr++;
1735
  (*curr)->data->pre_init = pre_init;
1736
  (*curr)->data->post_init = post_init;
1737
  (*curr)->data->init_p = 1;
1738
  return (*curr)->data;
1739
}
1740
 
1741
struct gdbarch_data *
1742
gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
1743
{
1744
  return gdbarch_data_register (pre_init, NULL);
1745
}
1746
 
1747
struct gdbarch_data *
1748
gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
1749
{
1750
  return gdbarch_data_register (NULL, post_init);
1751
}
1752
 
1753
/* Create/delete the gdbarch data vector. */
1754
 
1755
static void
1756
alloc_gdbarch_data (struct gdbarch *gdbarch)
1757
{
1758
  gdb_assert (gdbarch->data == NULL);
1759
  gdbarch->nr_data = gdbarch_data_registry.nr;
1760
  gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
1761
}
1762
 
1763
/* Initialize the current value of the specified per-architecture
1764
   data-pointer. */
1765
 
1766
void
1767
deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1768
                             struct gdbarch_data *data,
1769
                             void *pointer)
1770
{
1771
  gdb_assert (data->index < gdbarch->nr_data);
1772
  gdb_assert (gdbarch->data[data->index] == NULL);
1773
  gdb_assert (data->pre_init == NULL);
1774
  gdbarch->data[data->index] = pointer;
1775
}
1776
 
1777
/* Return the current value of the specified per-architecture
1778
   data-pointer. */
1779
 
1780
void *
1781
gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
1782
{
1783
  gdb_assert (data->index < gdbarch->nr_data);
1784
  if (gdbarch->data[data->index] == NULL)
1785
    {
1786
      /* The data-pointer isn't initialized, call init() to get a
1787
         value.  */
1788
      if (data->pre_init != NULL)
1789
        /* Mid architecture creation: pass just the obstack, and not
1790
           the entire architecture, as that way it isn't possible for
1791
           pre-init code to refer to undefined architecture
1792
           fields.  */
1793
        gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
1794
      else if (gdbarch->initialized_p
1795
               && data->post_init != NULL)
1796
        /* Post architecture creation: pass the entire architecture
1797
           (as all fields are valid), but be careful to also detect
1798
           recursive references.  */
1799
        {
1800
          gdb_assert (data->init_p);
1801
          data->init_p = 0;
1802
          gdbarch->data[data->index] = data->post_init (gdbarch);
1803
          data->init_p = 1;
1804
        }
1805
      else
1806
        /* The architecture initialization hasn't completed - punt -
1807
         hope that the caller knows what they are doing.  Once
1808
         deprecated_set_gdbarch_data has been initialized, this can be
1809
         changed to an internal error.  */
1810
        return NULL;
1811
      gdb_assert (gdbarch->data[data->index] != NULL);
1812
    }
1813
  return gdbarch->data[data->index];
1814
}
1815
 
1816
 
1817
/* Keep a registry of the architectures known by GDB. */
1818
 
1819
struct gdbarch_registration
1820
{
1821
  enum bfd_architecture bfd_architecture;
1822
  gdbarch_init_ftype *init;
1823
  gdbarch_dump_tdep_ftype *dump_tdep;
1824
  struct gdbarch_list *arches;
1825
  struct gdbarch_registration *next;
1826
};
1827
 
1828
static struct gdbarch_registration *gdbarch_registry = NULL;
1829
 
1830
static void
1831
append_name (const char ***buf, int *nr, const char *name)
1832
{
1833
  *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1834
  (*buf)[*nr] = name;
1835
  *nr += 1;
1836
}
1837
 
1838
const char **
1839
gdbarch_printable_names (void)
1840
{
1841
  /* Accumulate a list of names based on the registed list of
1842
     architectures. */
1843
  enum bfd_architecture a;
1844
  int nr_arches = 0;
1845
  const char **arches = NULL;
1846
  struct gdbarch_registration *rego;
1847
  for (rego = gdbarch_registry;
1848
       rego != NULL;
1849
       rego = rego->next)
1850
    {
1851
      const struct bfd_arch_info *ap;
1852
      ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1853
      if (ap == NULL)
1854
        internal_error (__FILE__, __LINE__,
1855
                        _("gdbarch_architecture_names: multi-arch unknown"));
1856
      do
1857
        {
1858
          append_name (&arches, &nr_arches, ap->printable_name);
1859
          ap = ap->next;
1860
        }
1861
      while (ap != NULL);
1862
    }
1863
  append_name (&arches, &nr_arches, NULL);
1864
  return arches;
1865
}
1866
 
1867
 
1868
void
1869
gdbarch_register (enum bfd_architecture bfd_architecture,
1870
                  gdbarch_init_ftype *init,
1871
                  gdbarch_dump_tdep_ftype *dump_tdep)
1872
{
1873
  struct gdbarch_registration **curr;
1874
  const struct bfd_arch_info *bfd_arch_info;
1875
  /* Check that BFD recognizes this architecture */
1876
  bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1877
  if (bfd_arch_info == NULL)
1878
    {
1879
      internal_error (__FILE__, __LINE__,
1880
                      _("gdbarch: Attempt to register unknown architecture (%d)"),
1881
                      bfd_architecture);
1882
    }
1883
  /* Check that we haven't seen this architecture before */
1884
  for (curr = &gdbarch_registry;
1885
       (*curr) != NULL;
1886
       curr = &(*curr)->next)
1887
    {
1888
      if (bfd_architecture == (*curr)->bfd_architecture)
1889
        internal_error (__FILE__, __LINE__,
1890
                        _("gdbarch: Duplicate registraration of architecture (%s)"),
1891
                        bfd_arch_info->printable_name);
1892
    }
1893
  /* log it */
1894
  if (gdbarch_debug)
1895
    fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
1896
                        bfd_arch_info->printable_name,
1897
                        host_address_to_string (init));
1898
  /* Append it */
1899
  (*curr) = XMALLOC (struct gdbarch_registration);
1900
  (*curr)->bfd_architecture = bfd_architecture;
1901
  (*curr)->init = init;
1902
  (*curr)->dump_tdep = dump_tdep;
1903
  (*curr)->arches = NULL;
1904
  (*curr)->next = NULL;
1905
}
1906
 
1907
void
1908
register_gdbarch_init (enum bfd_architecture bfd_architecture,
1909
                       gdbarch_init_ftype *init)
1910
{
1911
  gdbarch_register (bfd_architecture, init, NULL);
1912
}
1913
 
1914
 
1915
/* Look for an architecture using gdbarch_info.  */
1916
 
1917
struct gdbarch_list *
1918
gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1919
                             const struct gdbarch_info *info)
1920
{
1921
  for (; arches != NULL; arches = arches->next)
1922
    {
1923
      if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1924
        continue;
1925
      if (info->byte_order != arches->gdbarch->byte_order)
1926
        continue;
1927
      if (info->osabi != arches->gdbarch->osabi)
1928
        continue;
1929
      if (info->target_desc != arches->gdbarch->target_desc)
1930
        continue;
1931
      return arches;
1932
    }
1933
  return NULL;
1934
}
1935
 
1936
 
1937
/* Find an architecture that matches the specified INFO.  Create a new
1938
   architecture if needed.  Return that new architecture.  */
1939
 
1940
struct gdbarch *
1941
gdbarch_find_by_info (struct gdbarch_info info)
1942
{
1943
  struct gdbarch *new_gdbarch;
1944
  struct gdbarch_registration *rego;
1945
 
1946
  /* Fill in missing parts of the INFO struct using a number of
1947
     sources: "set ..."; INFOabfd supplied; and the global
1948
     defaults.  */
1949
  gdbarch_info_fill (&info);
1950
 
1951
  /* Must have found some sort of architecture. */
1952
  gdb_assert (info.bfd_arch_info != NULL);
1953
 
1954
  if (gdbarch_debug)
1955
    {
1956
      fprintf_unfiltered (gdb_stdlog,
1957
                          "gdbarch_find_by_info: info.bfd_arch_info %s\n",
1958
                          (info.bfd_arch_info != NULL
1959
                           ? info.bfd_arch_info->printable_name
1960
                           : "(null)"));
1961
      fprintf_unfiltered (gdb_stdlog,
1962
                          "gdbarch_find_by_info: info.byte_order %d (%s)\n",
1963
                          info.byte_order,
1964
                          (info.byte_order == BFD_ENDIAN_BIG ? "big"
1965
                           : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
1966
                           : "default"));
1967
      fprintf_unfiltered (gdb_stdlog,
1968
                          "gdbarch_find_by_info: info.osabi %d (%s)\n",
1969
                          info.osabi, gdbarch_osabi_name (info.osabi));
1970
      fprintf_unfiltered (gdb_stdlog,
1971
                          "gdbarch_find_by_info: info.abfd %s\n",
1972
                          host_address_to_string (info.abfd));
1973
      fprintf_unfiltered (gdb_stdlog,
1974
                          "gdbarch_find_by_info: info.tdep_info %s\n",
1975
                          host_address_to_string (info.tdep_info));
1976
    }
1977
 
1978
  /* Find the tdep code that knows about this architecture.  */
1979
  for (rego = gdbarch_registry;
1980
       rego != NULL;
1981
       rego = rego->next)
1982
    if (rego->bfd_architecture == info.bfd_arch_info->arch)
1983
      break;
1984
  if (rego == NULL)
1985
    {
1986
      if (gdbarch_debug)
1987
        fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
1988
                            "No matching architecture\n");
1989
      return 0;
1990
    }
1991
 
1992
  /* Ask the tdep code for an architecture that matches "info".  */
1993
  new_gdbarch = rego->init (info, rego->arches);
1994
 
1995
  /* Did the tdep code like it?  No.  Reject the change and revert to
1996
     the old architecture.  */
1997
  if (new_gdbarch == NULL)
1998
    {
1999
      if (gdbarch_debug)
2000
        fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2001
                            "Target rejected architecture\n");
2002
      return NULL;
2003
    }
2004
 
2005
  /* Is this a pre-existing architecture (as determined by already
2006
     being initialized)?  Move it to the front of the architecture
2007
     list (keeping the list sorted Most Recently Used).  */
2008
  if (new_gdbarch->initialized_p)
2009
    {
2010
      struct gdbarch_list **list;
2011
      struct gdbarch_list *this;
2012
      if (gdbarch_debug)
2013
        fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2014
                            "Previous architecture %s (%s) selected\n",
2015
                            host_address_to_string (new_gdbarch),
2016
                            new_gdbarch->bfd_arch_info->printable_name);
2017
      /* Find the existing arch in the list.  */
2018
      for (list = &rego->arches;
2019
           (*list) != NULL && (*list)->gdbarch != new_gdbarch;
2020
           list = &(*list)->next);
2021
      /* It had better be in the list of architectures.  */
2022
      gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
2023
      /* Unlink THIS.  */
2024
      this = (*list);
2025
      (*list) = this->next;
2026
      /* Insert THIS at the front.  */
2027
      this->next = rego->arches;
2028
      rego->arches = this;
2029
      /* Return it.  */
2030
      return new_gdbarch;
2031
    }
2032
 
2033
  /* It's a new architecture.  */
2034
  if (gdbarch_debug)
2035
    fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
2036
                        "New architecture %s (%s) selected\n",
2037
                        host_address_to_string (new_gdbarch),
2038
                        new_gdbarch->bfd_arch_info->printable_name);
2039
 
2040
  /* Insert the new architecture into the front of the architecture
2041
     list (keep the list sorted Most Recently Used).  */
2042
  {
2043
    struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
2044
    this->next = rego->arches;
2045
    this->gdbarch = new_gdbarch;
2046
    rego->arches = this;
2047
  }
2048
 
2049
  /* Check that the newly installed architecture is valid.  Plug in
2050
     any post init values.  */
2051
  new_gdbarch->dump_tdep = rego->dump_tdep;
2052
  verify_gdbarch (new_gdbarch);
2053
  new_gdbarch->initialized_p = 1;
2054
 
2055
  if (gdbarch_debug)
2056
    gdbarch_dump (new_gdbarch, gdb_stdlog);
2057
 
2058
  return new_gdbarch;
2059
}
2060
 
2061
/* Make the specified architecture current.  */
2062
 
2063
void
2064
deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
2065
{
2066
  gdb_assert (new_gdbarch != NULL);
2067
  gdb_assert (new_gdbarch->initialized_p);
2068
  target_gdbarch = new_gdbarch;
2069
  observer_notify_architecture_changed (new_gdbarch);
2070
  registers_changed ();
2071
}
2072
 
2073
extern void _initialize_gdbarch (void);
2074
 
2075
void
2076
_initialize_gdbarch (void)
2077
{
2078
  struct cmd_list_element *c;
2079
 
2080
  add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\\
2081
Set architecture debugging."), _("\\
2082
Show architecture debugging."), _("\\
2083
When non-zero, architecture debugging is enabled."),
2084
                            NULL,
2085
                            show_gdbarch_debug,
2086
                            &setdebuglist, &showdebuglist);
2087
}
2088
EOF
2089
 
2090
# close things off
2091
exec 1>&2
2092
#../move-if-change new-gdbarch.c gdbarch.c
2093
compare_new gdbarch.c

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.