gdb/gdbarch.sh

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