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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [gdbarch.sh] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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