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