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