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