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