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