gdb/gdbarch.sh

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