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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [gdbarch.sh] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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