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