gdb/gdbarch.sh

   1 #!/usr/local/bin/bash
   2
   3 # Architecture commands for GDB, the GNU debugger.
   4 # Copyright 1998-2000 Free Software Foundation, Inc.
   5 #
   6 # This file is part of GDB.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21
  22 compare_new ()
  23 {
  24     file=$1
  25     if ! test -r ${file}
  26     then
  27         echo "${file} missing? cp new-${file} ${file}" 1>&2
  28     elif diff -c ${file} new-${file}
  29     then
  30         echo "${file} unchanged" 1>&2
  31     else
  32         echo "${file} has changed? cp new-${file} ${file}" 1>&2
  33     fi
  34 }
  35
  36
  37 # DEFAULT is a valid fallback definition of a MACRO when
  38 # multi-arch is not enabled.
  39 default_is_fallback_p ()
  40 {
  41     [ "${predefault}" != "" -a "${invalid_p}" = "0" ]
  42 }
  43
  44 # Format of the input table
  45 read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
  46
  47 class_is_variable_p ()
  48 {
  49     [ "${class}" = "v" -o "${class}" = "V" ]
  50 }
  51
  52 class_is_function_p ()
  53 {
  54     [ "${class}" = "f" -o "${class}" = "F" ]
  55 }
  56
  57 class_is_predicate_p ()
  58 {
  59     [ "${class}" = "F" -o "${class}" = "V" ]
  60 }
  61
  62 class_is_info_p ()
  63 {
  64     [ "${class}" = "i" ]
  65 }
  66
  67
  68 do_read ()
  69 {
  70     if eval read $read
  71     then
  72         test "${staticdefault}" || staticdefault=0
  73         test "${fmt}" || fmt="%ld"
  74         test "${print}" || print="(long) ${macro}"
  75         #FIXME:
  76         #Should set PREDEFAULT to zero and force the user to provide
  77         #an invalid_p=0
  78         #test "${predefault}" || predefault=0 - NO
  79         case "${invalid_p}" in
  80             0 ) valid_p=1 ;;
  81             "" )
  82                 if [ "${predefault}" ]
  83                 then
  84                     valid_p="gdbarch->${function} != ${predefault}"
  85                 else
  86                     valid_p="gdbarch->${function} != 0"
  87                 fi
  88                 #NOT_YET
  89                 #test "${predefault}" && invalid_p="gdbarch->${function} == ${predefault}"
  90                 ;;
  91             * ) valid_p="!(${invalid_p})"
  92         esac
  93         #NOT YET:
  94         :
  95     else
  96         false
  97     fi
  98 }
  99
 100
 101 # dump out/verify the doco
 102 for field in ${read}
 103 do
 104   case ${field} in
 105
 106     class ) : ;;
 107
 108         # # -> line disable
 109         # f -> function
 110         #   hiding a function
 111         # F -> function + predicate
 112         #   hiding a function + predicate to test function validity
 113         # v -> variable
 114         #   hiding a variable
 115         # V -> variable + predicate
 116         #   hiding a variable + predicate to test variables validity
 117         # i -> set from info
 118         #   hiding something from the ``struct info'' object
 119
 120     level ) : ;;
 121
 122         # See GDB_MULTI_ARCH description.  Having GDB_MULTI_ARCH >=
 123         # LEVEL is a predicate on checking that a given method is
 124         # initialized (using INVALID_P).
 125
 126     macro ) : ;;
 127
 128         # The name of the MACRO that this method is to be accessed by.
 129
 130     returntype ) : ;;
 131
 132         # For functions, the return type; for variables, the data type
 133
 134     function ) : ;;
 135
 136         # For functions, the member function name; for variables, the
 137         # variable name.  Member function names are always prefixed with
 138         # ``gdbarch_'' for name-space purity.
 139
 140     formal ) : ;;
 141
 142         # The formal argument list.  It is assumed that the formal
 143         # argument list includes the actual name of each list element.
 144         # A function with no arguments shall have ``void'' as the
 145         # formal argument list.
 146
 147     actual ) : ;;
 148
 149         # The list of actual arguments.  The arguments specified shall
 150         # match the FORMAL list given above.  Functions with out
 151         # arguments leave this blank.
 152
 153     attrib ) : ;;
 154
 155         # Any GCC attributes that should be attached to the function
 156         # declaration.  At present this field is unused.
 157
 158     staticdefault ) : ;;
 159
 160         # To help with the GDB startup a static gdbarch object is
 161         # created.  STATICDEFAULT is the value to insert into that
 162         # static gdbarch object.  Since this a static object only
 163         # simple expressions can be used.
 164
 165         # If STATICDEFAULT is empty, zero is used.
 166
 167     predefault ) : ;;
 168
 169         # A initial value to assign to MEMBER of the freshly
 170         # malloc()ed gdbarch object.  After the gdbarch object has
 171         # been initialized using PREDEFAULT, it is passed to the
 172         # target code for further updates.
 173
 174         # If PREDEFAULT is empty, zero is used.
 175
 176         # Specify a non-empty PREDEFAULT and a zero INVALID_P to
 177         # create a fallback value or function for when multi-arch is
 178         # disabled.  Specify a zero PREDEFAULT function to make that
 179         # fallback call internal_error().
 180
 181     postdefault ) : ;;
 182
 183         # A value to assign to MEMBER of the new gdbarch object should
 184         # the target code fail to change the PREDEFAULT value.
 185
 186         # If POSTDEFAULT is empty, no post update is performed.
 187
 188         # If both INVALID_P and POSTDEFAULT are non-empty then
 189         # INVALID_P will be used to determine if MEMBER should be
 190         # changed to POSTDEFAULT.
 191
 192         # FIXME: NOT YET.  Can this be simplified?  Specify a
 193         # non-empty POSTDEFAULT and a zero INVALID_P to create a
 194         # fallback value or function for when multi-arch is disabled.
 195         # Specify a zero POSTDEFAULT function to make that fallback
 196         # call internal_error(). This overrides PREDEFAULT.
 197
 198     invalid_p ) : ;;
 199
 200         # A predicate equation that validates MEMBER.  Non-zero is
 201         # returned if the code creating the new architecture failed to
 202         # initialize MEMBER or the initialized the member is invalid.
 203         # If POSTDEFAULT is non-empty then MEMBER will be updated to
 204         # that value.  If POSTDEFAULT is empty then internal_error()
 205         # is called.
 206
 207         # If INVALID_P is empty, a check that MEMBER is no longer
 208         # equal to PREDEFAULT is used.
 209
 210         # The expression ``0'' disables the INVALID_P check.
 211
 212         # See also PREDEFAULT and POSTDEFAULT.
 213
 214     fmt ) : ;;
 215
 216         # printf style format string that can be used to print out the
 217         # MEMBER.  Sometimes "%s" is useful.  For functions, this is
 218         # ignored and the function address is printed.
 219
 220         # If FMT is empty, ``%ld'' is used.
 221
 222     print ) : ;;
 223
 224         # An optional equation that casts MEMBER to a value suitable
 225         # for formatting by FMT.
 226
 227         # If PRINT is empty, ``(long)'' is used.
 228
 229     print_p ) : ;;
 230
 231         # An optional indicator for any predicte to wrap around the
 232         # print member code.
 233
 234         #   exp -> Wrap print up in ``if (${print_p}) ...
 235         #   ``'' -> No predicate
 236
 237         # If PRINT_P is empty, ``1'' is always used.
 238
 239     description ) : ;;
 240
 241         # Currently unused.
 242
 243     *) exit 1;;
 244   esac
 245 done
 246
 247 IFS=:
 248
 249 function_list ()
 250 {
 251   # See below (DOCO) for description of each field
 252   cat <<EOF |
 253 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
 254 #
 255 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
 256 #
 257 v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
 258 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
 259 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
 260 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
 261 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
 262 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
 263 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
 264 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
 265 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
 266 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
 267 v:1:IEEE_FLOAT:int:ieee_float::::0:0::0:::
 268 #
 269 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
 270 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
 271 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
 272 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
 273 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
 274 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
 275 #
 276 v:2:NUM_REGS:int:num_regs::::0:-1
 277 v:2:SP_REGNUM:int:sp_regnum::::0:-1
 278 v:2:FP_REGNUM:int:fp_regnum::::0:-1
 279 v:2:PC_REGNUM:int:pc_regnum::::0:-1
 280 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
 281 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
 282 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
 283 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
 284 v:2:REGISTER_SIZE:int:register_size::::0:-1
 285 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
 286 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
 287 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
 288 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
 289 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
 290 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
 291 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
 292 #
 293 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
 294 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
 295 f:2:CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void:::0:0::gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0
 296 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
 297 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx
 298 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
 299 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
 300 f:2:PC_IN_CALL_DUMMY:int:pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::0:0
 301 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
 302 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
 303 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
 304 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
 305 v:2:CALL_DUMMY_STACK_ADJUST:int:call_dummy_stack_adjust::::0:::gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0:0x%08lx::CALL_DUMMY_STACK_ADJUST_P
 306 f:2:FIX_CALL_DUMMY:void:fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p:::0
 307 #
 308 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::
 309 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::
 310 f:2:COERCE_FLOAT_TO_DOUBLE:int:coerce_float_to_double:struct type *formal, struct type *actual:formal, actual:::default_coerce_float_to_double::0
 311 f:1:GET_SAVED_REGISTER:void:get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval::generic_get_saved_register:0
 312 #
 313 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
 314 f:2:REGISTER_CONVERT_TO_VIRTUAL:void:register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to:::0::0
 315 f:2:REGISTER_CONVERT_TO_RAW:void:register_convert_to_raw:struct type *type, int regnum, char *from, char *to:type, regnum, from, to:::0::0
 316 #
 317 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, char *buf:type, buf:::generic_pointer_to_address::0
 318 f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, char *buf, CORE_ADDR addr:type, buf, addr:::generic_address_to_pointer::0
 319 #
 320 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
 321 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
 322 f:1:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr::0:0
 323 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
 324 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
 325 f:2:POP_FRAME:void:pop_frame:void:-:::0
 326 #
 327 # I wish that these would just go away....
 328 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
 329 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
 330 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
 331 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
 332 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
 333 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
 334 #
 335 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
 336 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
 337 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
 338 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
 339 #
 340 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
 341 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
 342 #
 343 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
 344 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
 345 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
 346 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
 347 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
 348 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
 349 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
 350 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
 351 #
 352 f:2:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
 353 #
 354 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
 355 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
 356 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
 357 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
 358 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
 359 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
 360 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
 361 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
 362 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
 363 #
 364 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
 365 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
 366 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
 367 EOF
 368   grep -v '^#'
 369 }
 370
 371 #
 372 # The .log file
 373 #
 374 exec > new-gdbarch.log
 375 function_list | while do_read # eval read $read
 376 do
 377     cat <<EOF
 378 ${class} ${macro}(${actual})
 379   ${returntype} ${function} ($formal)${attrib}
 380     level=${level}
 381     staticdefault=${staticdefault}
 382     predefault=${predefault}
 383     postdefault=${predefault}
 384     invalid_p=${invalid_p}
 385     valid_p=${valid_p}
 386     fmt=${fmt}
 387     print=${print}
 388     print_p=${print_p}
 389     description=${description}
 390 EOF
 391     if class_is_predicate_p && default_is_fallback_p
 392     then
 393         echo "Error: predicate function can not have a non- multi-arch default" 1>&2
 394         kill $$
 395         exit 1
 396     fi
 397 done
 398
 399 exec 1>&2
 400 compare_new gdbarch.log
 401
 402
 403 copyright ()
 404 {
 405 cat <<EOF
 406 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 407
 408 /* Dynamic architecture support for GDB, the GNU debugger.
 409    Copyright 1998-1999, Free Software Foundation, Inc.
 410
 411    This file is part of GDB.
 412
 413    This program is free software; you can redistribute it and/or modify
 414    it under the terms of the GNU General Public License as published by
 415    the Free Software Foundation; either version 2 of the License, or
 416    (at your option) any later version.
 417
 418    This program is distributed in the hope that it will be useful,
 419    but WITHOUT ANY WARRANTY; without even the implied warranty of
 420    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 421    GNU General Public License for more details.
 422
 423    You should have received a copy of the GNU General Public License
 424    along with this program; if not, write to the Free Software
 425    Foundation, Inc., 59 Temple Place - Suite 330,
 426    Boston, MA 02111-1307, USA.  */
 427
 428 /* This file was created with the aid of \`\`gdbarch.sh''.
 429
 430    The bourn shell script \`\`gdbarch.sh'' creates the files
 431    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
 432    against the existing \`\`gdbarch.[hc]''.  Any differences found
 433    being reported.
 434
 435    If editing this file, please also run gdbarch.sh and merge any
 436    changes into that script. Conversely, when makeing sweeping changes
 437    to this file, modifying gdbarch.sh and using its output may prove
 438    easier. */
 439
 440 EOF
 441 }
 442
 443 #
 444 # The .h file
 445 #
 446
 447 exec > new-gdbarch.h
 448 copyright
 449 cat <<EOF
 450 #ifndef GDBARCH_H
 451 #define GDBARCH_H
 452
 453 struct frame_info;
 454 struct value;
 455
 456
 457 #ifndef GDB_MULTI_ARCH
 458 #define GDB_MULTI_ARCH 0
 459 #endif
 460
 461 extern struct gdbarch *current_gdbarch;
 462
 463
 464 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
 465    macro */
 466
 467
 468 /* If any of the following are defined, the target wasn't correctly
 469    converted. */
 470
 471 #if GDB_MULTI_ARCH
 472 #if defined (EXTRA_FRAME_INFO)
 473 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
 474 #endif
 475 #endif
 476
 477 #if GDB_MULTI_ARCH
 478 #if defined (FRAME_FIND_SAVED_REGS)
 479 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
 480 #endif
 481 #endif
 482 EOF
 483
 484 # function typedef's
 485 echo ""
 486 echo ""
 487 echo "/* The following are pre-initialized by GDBARCH. */"
 488 function_list | while do_read # eval read $read
 489 do
 490     if class_is_info_p
 491     then
 492         echo ""
 493         echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
 494         echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
 495         echo "#if GDB_MULTI_ARCH"
 496         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
 497         echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
 498         echo "#endif"
 499         echo "#endif"
 500     fi
 501 done
 502
 503 # function typedef's
 504 echo ""
 505 echo ""
 506 echo "/* The following are initialized by the target dependant code. */"
 507 function_list | while do_read # eval read $read
 508 do
 509     if class_is_predicate_p
 510     then
 511         echo ""
 512         echo "#if defined (${macro})"
 513         echo "/* Legacy for systems yet to multi-arch ${macro} */"
 514 #       echo "#if (GDB_MULTI_ARCH <= 2) && defined (${macro})"
 515         echo "#define ${macro}_P() (1)"
 516         echo "#endif"
 517         echo ""
 518         echo "/* Default predicate for non- multi-arch targets. */"
 519         echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro}_P)"
 520         echo "#define ${macro}_P() (0)"
 521         echo "#endif"
 522         echo ""
 523         echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
 524         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro}_P)"
 525         echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
 526         echo "#endif"
 527     fi
 528     if class_is_variable_p
 529     then
 530         if default_is_fallback_p || class_is_predicate_p
 531         then
 532             echo ""
 533             echo "/* Default (value) for non- multi-arch platforms. */"
 534             echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
 535             echo "#define ${macro} (${predefault})"
 536             echo "#endif"
 537         fi
 538         echo ""
 539         echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
 540         echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
 541         echo "#if GDB_MULTI_ARCH"
 542         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
 543         echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
 544         echo "#endif"
 545         echo "#endif"
 546     fi
 547     if class_is_function_p
 548     then
 549         if default_is_fallback_p || class_is_predicate_p
 550         then
 551             echo ""
 552             echo "/* Default (function) for non- multi-arch platforms. */"
 553             echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
 554             if [ "${predefault}" = "0" ]
 555             then
 556                 echo "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)"
 557             else
 558                 echo "#define ${macro}(${actual}) (${predefault} (${actual}))"
 559             fi
 560             echo "#endif"
 561         fi
 562         echo ""
 563         echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
 564         if [ "${formal}" = "void" ]
 565         then
 566           echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
 567         else
 568           echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
 569         fi
 570         echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
 571         echo "#if GDB_MULTI_ARCH"
 572         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
 573         if [ "${actual}" = "" ]
 574         then
 575           echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
 576         elif [ "${actual}" = "-" ]
 577         then
 578           echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
 579         else
 580           echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
 581         fi
 582         echo "#endif"
 583         echo "#endif"
 584     fi
 585 done
 586
 587 # close it off
 588 cat <<EOF
 589
 590 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
 591
 592
 593 /* Mechanism for co-ordinating the selection of a specific
 594    architecture.
 595
 596    GDB targets (*-tdep.c) can register an interest in a specific
 597    architecture.  Other GDB components can register a need to maintain
 598    per-architecture data.
 599
 600    The mechanisms below ensures that there is only a loose connection
 601    between the set-architecture command and the various GDB
 602    components.  Each component can independantly register their need
 603    to maintain architecture specific data with gdbarch.
 604
 605    Pragmatics:
 606
 607    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
 608    didn't scale.
 609
 610    The more traditional mega-struct containing architecture specific
 611    data for all the various GDB components was also considered.  Since
 612    GDB is built from a variable number of (fairly independant)
 613    components it was determined that the global aproach was not
 614    applicable. */
 615
 616
 617 /* Register a new architectural family with GDB.
 618
 619    Register support for the specified ARCHITECTURE with GDB.  When
 620    gdbarch determines that the specified architecture has been
 621    selected, the corresponding INIT function is called.
 622
 623    --
 624
 625    The INIT function takes two parameters: INFO which contains the
 626    information available to gdbarch about the (possibly new)
 627    architecture; ARCHES which is a list of the previously created
 628    \`\`struct gdbarch'' for this architecture.
 629
 630    The INIT function parameter INFO shall, as far as possible, be
 631    pre-initialized with information obtained from INFO.ABFD or
 632    previously selected architecture (if similar).  INIT shall ensure
 633    that the INFO.BYTE_ORDER is non-zero.
 634
 635    The INIT function shall return any of: NULL - indicating that it
 636    doesn't reconize the selected architecture; an existing \`\`struct
 637    gdbarch'' from the ARCHES list - indicating that the new
 638    architecture is just a synonym for an earlier architecture (see
 639    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
 640    - that describes the selected architecture (see
 641    gdbarch_alloc()). */
 642
 643 struct gdbarch_list
 644 {
 645   struct gdbarch *gdbarch;
 646   struct gdbarch_list *next;
 647 };
 648
 649 struct gdbarch_info
 650 {
 651   /* Use default: bfd_arch_unknown (ZERO). */
 652   enum bfd_architecture bfd_architecture;
 653
 654   /* Use default: NULL (ZERO). */
 655   const struct bfd_arch_info *bfd_arch_info;
 656
 657   /* Use default: 0 (ZERO). */
 658   int byte_order;
 659
 660   /* Use default: NULL (ZERO). */
 661   bfd *abfd;
 662
 663   /* Use default: NULL (ZERO). */
 664   struct gdbarch_tdep_info *tdep_info;
 665 };
 666
 667 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
 668
 669 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 670
 671
 672 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 673    matches the information provided by INFO. */
 674
 675 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
 676
 677
 678 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
 679    basic initialization using values obtained from the INFO andTDEP
 680    parameters.  set_gdbarch_*() functions are called to complete the
 681    initialization of the object. */
 682
 683 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 684
 685
 686 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.  */
 687 extern void gdbarch_free (struct gdbarch *);
 688
 689
 690 /* Helper function. Force an update of the current architecture.  Used
 691    by legacy targets that have added their own target specific
 692    architecture manipulation commands.
 693
 694    The INFO parameter shall be fully initialized (\`\`memset (&INFO,
 695    sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
 696    called.  gdbarch_update() shall initialize any \`\`default'' fields
 697    using information obtained from the previous architecture or
 698    INFO.ABFD (if specified) before calling the corresponding
 699    architectures INIT function. */
 700
 701 extern int gdbarch_update (struct gdbarch_info info);
 702
 703
 704
 705 /* Register per-architecture data-pointer.
 706
 707    Reserve space for a per-architecture data-pointer.  An identifier
 708    for the reserved data-pointer is returned.  That identifer should
 709    be saved in a local static.
 710
 711    When a new architecture is selected, INIT() is called.  When a
 712    previous architecture is re-selected, the per-architecture
 713    data-pointer for that previous architecture is restored (INIT() is
 714    not called).
 715
 716    INIT() shall return the initial value for the per-architecture
 717    data-pointer for the current architecture.
 718
 719    Multiple registrarants for any architecture are allowed (and
 720    strongly encouraged).  */
 721
 722 typedef void *(gdbarch_data_ftype) (void);
 723 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
 724
 725 /* Return the value of the per-architecture data-pointer for the
 726    current architecture. */
 727
 728 extern void *gdbarch_data (struct gdbarch_data*);
 729
 730
 731
 732 /* Register per-architecture memory region.
 733
 734    Provide a memory-region swap mechanism.  Per-architecture memory
 735    region are created.  These memory regions are swapped whenever the
 736    architecture is changed.  For a new architecture, the memory region
 737    is initialized with zero (0) and the INIT function is called.
 738
 739    Memory regions are swapped / initialized in the order that they are
 740    registered.  NULL DATA and/or INIT values can be specified.
 741
 742    New code should use register_gdbarch_data(). */
 743
 744 typedef void (gdbarch_swap_ftype) (void);
 745 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
 746 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 747
 748
 749
 750 /* The target-system-dependant byte order is dynamic */
 751
 752 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 753    is selectable at runtime.  The user can use the \`\`set endian''
 754    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 755    target_byte_order should be auto-detected (from the program image
 756    say). */
 757
 758 #if GDB_MULTI_ARCH
 759 /* Multi-arch GDB is always bi-endian. */
 760 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 761 #endif
 762
 763 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 764 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 765    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 766 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 767 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 768 #else
 769 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 770 #endif
 771 #endif
 772
 773 extern int target_byte_order;
 774 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 775 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 776    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 777 #undef TARGET_BYTE_ORDER
 778 #endif
 779 #ifndef TARGET_BYTE_ORDER
 780 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 781 #endif
 782
 783 extern int target_byte_order_auto;
 784 #ifndef TARGET_BYTE_ORDER_AUTO
 785 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 786 #endif
 787
 788
 789
 790 /* The target-system-dependant BFD architecture is dynamic */
 791
 792 extern int target_architecture_auto;
 793 #ifndef TARGET_ARCHITECTURE_AUTO
 794 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 795 #endif
 796
 797 extern const struct bfd_arch_info *target_architecture;
 798 #ifndef TARGET_ARCHITECTURE
 799 #define TARGET_ARCHITECTURE (target_architecture + 0)
 800 #endif
 801
 802 /* Notify the target dependant backend of a change to the selected
 803    architecture. A zero return status indicates that the target did
 804    not like the change. */
 805
 806 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
 807
 808
 809
 810 /* The target-system-dependant disassembler is semi-dynamic */
 811
 812 #include "dis-asm.h"            /* Get defs for disassemble_info */
 813
 814 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
 815                                 unsigned int len, disassemble_info *info);
 816
 817 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
 818                                   disassemble_info *info);
 819
 820 extern void dis_asm_print_address (bfd_vma addr,
 821                                    disassemble_info *info);
 822
 823 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
 824 extern disassemble_info tm_print_insn_info;
 825 #ifndef TARGET_PRINT_INSN
 826 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
 827 #endif
 828 #ifndef TARGET_PRINT_INSN_INFO
 829 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
 830 #endif
 831
 832
 833
 834 /* Explicit test for D10V architecture.
 835    USE of these macro's is *STRONGLY* discouraged. */
 836
 837 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
 838
 839
 840 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
 841 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
 842 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
 843 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
 844 #else
 845 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
 846 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
 847 #endif
 848 #endif
 849
 850
 851 /* Set the dynamic target-system-dependant parameters (architecture,
 852    byte-order, ...) using information found in the BFD */
 853
 854 extern void set_gdbarch_from_file (bfd *);
 855
 856
 857 /* Explicitly set the dynamic target-system-dependant parameters based
 858    on bfd_architecture and machine. */
 859
 860 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
 861
 862
 863 /* Initialize the current architecture to the "first" one we find on
 864    our list.  */
 865
 866 extern void initialize_current_architecture (void);
 867
 868 /* Helper function for targets that don't know how my arguments are
 869    being passed */
 870
 871 extern int frame_num_args_unknown (struct frame_info *fi);
 872
 873
 874 /* gdbarch trace variable */
 875 extern int gdbarch_debug;
 876
 877 extern void gdbarch_dump (void);
 878
 879 #endif
 880 EOF
 881 exec 1>&2
 882 #../move-if-change new-gdbarch.h gdbarch.h
 883 compare_new gdbarch.h
 884
 885
 886 #
 887 # C file
 888 #
 889
 890 exec > new-gdbarch.c
 891 copyright
 892 cat <<EOF
 893
 894 #include "defs.h"
 895 #include "arch-utils.h"
 896
 897 #if GDB_MULTI_ARCH
 898 #include "gdbcmd.h"
 899 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
 900 #else
 901 /* Just include everything in sight so that the every old definition
 902    of macro is visible. */
 903 #include "gdb_string.h"
 904 #include <ctype.h>
 905 #include "symtab.h"
 906 #include "frame.h"
 907 #include "inferior.h"
 908 #include "breakpoint.h"
 909 #include "gdb_wait.h"
 910 #include "gdbcore.h"
 911 #include "gdbcmd.h"
 912 #include "target.h"
 913 #include "gdbthread.h"
 914 #include "annotate.h"
 915 #include "symfile.h"            /* for overlay functions */
 916 #endif
 917 #include "symcat.h"
 918
 919
 920 /* Static function declarations */
 921
 922 static void verify_gdbarch (struct gdbarch *gdbarch);
 923 static void init_gdbarch_data (struct gdbarch *);
 924 static void init_gdbarch_swap (struct gdbarch *);
 925 static void swapout_gdbarch_swap (struct gdbarch *);
 926 static void swapin_gdbarch_swap (struct gdbarch *);
 927
 928 /* Convenience macro for allocting typesafe memory. */
 929
 930 #ifndef XMALLOC
 931 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
 932 #endif
 933
 934
 935 /* Non-zero if we want to trace architecture code.  */
 936
 937 #ifndef GDBARCH_DEBUG
 938 #define GDBARCH_DEBUG 0
 939 #endif
 940 int gdbarch_debug = GDBARCH_DEBUG;
 941
 942 EOF
 943
 944 # gdbarch open the gdbarch object
 945 echo ""
 946 echo "/* Maintain the struct gdbarch object */"
 947 echo ""
 948 echo "struct gdbarch"
 949 echo "{"
 950 echo "  /* basic architectural information */"
 951 function_list | while do_read # eval read $read
 952 do
 953     if class_is_info_p
 954     then
 955         echo "  ${returntype} ${function};"
 956     fi
 957 done
 958 echo ""
 959 echo "  /* target specific vector. */"
 960 echo "  struct gdbarch_tdep *tdep;"
 961 echo ""
 962 echo "  /* per-architecture data-pointers */"
 963 echo "  int nr_data;"
 964 echo "  void **data;"
 965 echo ""
 966 echo "  /* per-architecture swap-regions */"
 967 echo "  struct gdbarch_swap *swap;"
 968 echo ""
 969 cat <<EOF
 970   /* Multi-arch values.
 971
 972      When extending this structure you must:
 973
 974      Add the field below.
 975
 976      Declare set/get functions and define the corresponding
 977      macro in gdbarch.h.
 978
 979      gdbarch_alloc(): If zero/NULL is not a suitable default,
 980      initialize the new field.
 981
 982      verify_gdbarch(): Confirm that the target updated the field
 983      correctly.
 984
 985      gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
 986      field is dumped out
 987
 988      \`\`startup_gdbarch()'': Append an initial value to the static
 989      variable (base values on the host's c-type system).
 990
 991      get_gdbarch(): Implement the set/get functions (probably using
 992      the macro's as shortcuts).
 993
 994      */
 995
 996 EOF
 997 function_list | while do_read # eval read $read
 998 do
 999     if class_is_variable_p
1000     then
1001         echo "  ${returntype} ${function};"
1002     elif class_is_function_p
1003     then
1004         echo "  gdbarch_${function}_ftype *${function}${attrib};"
1005     fi
1006 done
1007 echo "};"
1008
1009 # A pre-initialized vector
1010 echo ""
1011 echo ""
1012 cat <<EOF
1013 /* The default architecture uses host values (for want of a better
1014    choice). */
1015 EOF
1016 echo ""
1017 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
1018 echo ""
1019 echo "struct gdbarch startup_gdbarch = {"
1020 echo "  /* basic architecture information */"
1021 function_list | while do_read # eval read $read
1022 do
1023     if class_is_info_p
1024     then
1025         echo "  ${staticdefault},"
1026     fi
1027 done
1028 cat <<EOF
1029   /* target specific vector */
1030   NULL,
1031   /*per-architecture data-pointers and swap regions */
1032   0, NULL, NULL,
1033   /* Multi-arch values */
1034 EOF
1035 function_list | while do_read # eval read $read
1036 do
1037     if class_is_function_p || class_is_variable_p
1038     then
1039         echo "  ${staticdefault},"
1040     fi
1041 done
1042 cat <<EOF
1043   /* startup_gdbarch() */
1044 };
1045 struct gdbarch *current_gdbarch = &startup_gdbarch;
1046 EOF
1047
1048 # Create a new gdbarch struct
1049 echo ""
1050 echo ""
1051 cat <<EOF
1052 /* Create a new \`\`struct gdbarch'' based in information provided by
1053    \`\`struct gdbarch_info''. */
1054 EOF
1055 echo ""
1056 cat <<EOF
1057 struct gdbarch *
1058 gdbarch_alloc (const struct gdbarch_info *info,
1059                struct gdbarch_tdep *tdep)
1060 {
1061   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1062   memset (gdbarch, 0, sizeof (*gdbarch));
1063
1064   gdbarch->tdep = tdep;
1065 EOF
1066 echo ""
1067 function_list | while do_read # eval read $read
1068 do
1069     if class_is_info_p
1070     then
1071         echo "  gdbarch->${function} = info->${function};"
1072     fi
1073 done
1074 echo ""
1075 echo "  /* Force the explicit initialization of these. */"
1076 function_list | while do_read # eval read $read
1077 do
1078     if class_is_function_p || class_is_variable_p
1079     then
1080         if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1081         then
1082           echo "  gdbarch->${function} = ${predefault};"
1083         fi
1084     fi
1085 done
1086 cat <<EOF
1087   /* gdbarch_alloc() */
1088
1089   return gdbarch;
1090 }
1091 EOF
1092
1093 # Free a gdbarch struct.
1094 echo ""
1095 echo ""
1096 cat <<EOF
1097 /* Free a gdbarch struct.  This should never happen in normal
1098    operation --- once you've created a gdbarch, you keep it around.
1099    However, if an architecture's init function encounters an error
1100    building the structure, it may need to clean up a partially
1101    constructed gdbarch.  */
1102 void
1103 gdbarch_free (struct gdbarch *arch)
1104 {
1105   /* At the moment, this is trivial.  */
1106   free (arch);
1107 }
1108 EOF
1109
1110 # verify a new architecture
1111 echo ""
1112 echo ""
1113 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1114 echo ""
1115 cat <<EOF
1116 static void
1117 verify_gdbarch (struct gdbarch *gdbarch)
1118 {
1119   /* Only perform sanity checks on a multi-arch target. */
1120   if (GDB_MULTI_ARCH <= 0)
1121     return;
1122   /* fundamental */
1123   if (gdbarch->byte_order == 0)
1124     internal_error ("verify_gdbarch: byte-order unset");
1125   if (gdbarch->bfd_arch_info == NULL)
1126     internal_error ("verify_gdbarch: bfd_arch_info unset");
1127   /* Check those that need to be defined for the given multi-arch level. */
1128 EOF
1129 function_list | while do_read # eval read $read
1130 do
1131     if class_is_function_p || class_is_variable_p
1132     then
1133         if [ "${invalid_p}" = "0" ]
1134         then
1135             echo "  /* Skip verify of ${function}, invalid_p == 0 */"
1136         elif class_is_predicate_p
1137         then
1138             echo "  /* Skip verify of ${function}, has predicate */"
1139         elif [ "${invalid_p}" ]
1140         then
1141             echo "  if ((GDB_MULTI_ARCH >= ${level})"
1142             echo "      && (${invalid_p}))"
1143             echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1144         elif [ "${predefault}" ]
1145         then
1146             echo "  if ((GDB_MULTI_ARCH >= ${level})"
1147             echo "      && (gdbarch->${function} == ${predefault}))"
1148             echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1149         fi
1150     fi
1151 done
1152 cat <<EOF
1153 }
1154 EOF
1155
1156 # dump the structure
1157 echo ""
1158 echo ""
1159 echo "/* Print out the details of the current architecture. */"
1160 echo ""
1161 cat <<EOF
1162 void
1163 gdbarch_dump (void)
1164 {
1165 EOF
1166 function_list | while do_read # eval read $read
1167 do
1168     echo "#ifdef ${macro}"
1169     if class_is_function_p
1170     then
1171         echo "  fprintf_unfiltered (gdb_stdlog,"
1172         echo "                      \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1173         echo "                      (long) current_gdbarch->${function}"
1174         echo "                      /*${macro} ()*/);"
1175     else
1176         if [ "${print_p}" ]
1177         then
1178           echo "  if (${print_p})"
1179           echo "    fprintf_unfiltered (gdb_stdlog,"
1180           echo "                        \"gdbarch_update: ${macro} = ${fmt}\\n\","
1181           echo "                        ${print});"
1182         else
1183           echo "  fprintf_unfiltered (gdb_stdlog,"
1184           echo "                      \"gdbarch_update: ${macro} = ${fmt}\\n\","
1185           echo "                      ${print});"
1186         fi
1187     fi
1188     echo "#endif"
1189 done
1190 cat <<EOF
1191   fprintf_unfiltered (gdb_stdlog,
1192                       "gdbarch_update: GDB_MULTI_ARCH = %d\\n",
1193                       GDB_MULTI_ARCH);
1194 }
1195 EOF
1196
1197
1198 # GET/SET
1199 echo ""
1200 cat <<EOF
1201 struct gdbarch_tdep *
1202 gdbarch_tdep (struct gdbarch *gdbarch)
1203 {
1204   if (gdbarch_debug >= 2)
1205     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1206   return gdbarch->tdep;
1207 }
1208 EOF
1209 echo ""
1210 function_list | while do_read # eval read $read
1211 do
1212     if class_is_predicate_p
1213     then
1214         echo ""
1215         echo "int"
1216         echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1217         echo "{"
1218         if [ "${valid_p}" ]
1219         then
1220             echo "  return ${valid_p};"
1221         else
1222             echo "#error \"gdbarch_${function}_p: not defined\""
1223         fi
1224         echo "}"
1225     fi
1226     if class_is_function_p
1227     then
1228         echo ""
1229         echo "${returntype}"
1230         if [ "${formal}" = "void" ]
1231         then
1232           echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1233         else
1234           echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1235         fi
1236         echo "{"
1237         echo "  if (gdbarch->${function} == 0)"
1238         echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1239         echo "  if (gdbarch_debug >= 2)"
1240         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1241         test "${actual}" = "-" && actual=""
1242         if [ "${returntype}" = "void" ]
1243         then
1244           echo "  gdbarch->${function} (${actual});"
1245         else
1246           echo "  return gdbarch->${function} (${actual});"
1247         fi
1248         echo "}"
1249         echo ""
1250         echo "void"
1251         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1252         echo "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})"
1253         echo "{"
1254         echo "  gdbarch->${function} = ${function};"
1255         echo "}"
1256     elif class_is_variable_p
1257     then
1258         echo ""
1259         echo "${returntype}"
1260         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1261         echo "{"
1262         if [ "${invalid_p}" = "0" ]
1263         then
1264             echo "  /* Skip verify of ${function}, invalid_p == 0 */"
1265         elif [ "${invalid_p}" ]
1266         then
1267           echo "  if (${invalid_p})"
1268           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1269         elif [ "${predefault}" ]
1270         then
1271           echo "  if (gdbarch->${function} == ${predefault})"
1272           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1273         fi
1274         echo "  if (gdbarch_debug >= 2)"
1275         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1276         echo "  return gdbarch->${function};"
1277         echo "}"
1278         echo ""
1279         echo "void"
1280         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1281         echo "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})"
1282         echo "{"
1283         echo "  gdbarch->${function} = ${function};"
1284         echo "}"
1285     elif class_is_info_p
1286     then
1287         echo ""
1288         echo "${returntype}"
1289         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1290         echo "{"
1291         echo "  if (gdbarch_debug >= 2)"
1292         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1293         echo "  return gdbarch->${function};"
1294         echo "}"
1295     fi
1296 done
1297
1298 # All the trailing guff
1299 cat <<EOF
1300
1301
1302 /* Keep a registrary of per-architecture data-pointers required by GDB
1303    modules. */
1304
1305 struct gdbarch_data
1306 {
1307   int index;
1308 };
1309
1310 struct gdbarch_data_registration
1311 {
1312   gdbarch_data_ftype *init;
1313   struct gdbarch_data *data;
1314   struct gdbarch_data_registration *next;
1315 };
1316
1317 struct gdbarch_data_registrary
1318 {
1319   int nr;
1320   struct gdbarch_data_registration *registrations;
1321 };
1322
1323 struct gdbarch_data_registrary gdbarch_data_registrary =
1324 {
1325   0, NULL,
1326 };
1327
1328 struct gdbarch_data *
1329 register_gdbarch_data (gdbarch_data_ftype *init)
1330 {
1331   struct gdbarch_data_registration **curr;
1332   for (curr = &gdbarch_data_registrary.registrations;
1333        (*curr) != NULL;
1334        curr = &(*curr)->next);
1335   (*curr) = XMALLOC (struct gdbarch_data_registration);
1336   (*curr)->next = NULL;
1337   (*curr)->init = init;
1338   (*curr)->data = XMALLOC (struct gdbarch_data);
1339   (*curr)->data->index = gdbarch_data_registrary.nr++;
1340   return (*curr)->data;
1341 }
1342
1343
1344 /* Walk through all the registered users initializing each in turn. */
1345
1346 static void
1347 init_gdbarch_data (struct gdbarch *gdbarch)
1348 {
1349   struct gdbarch_data_registration *rego;
1350   gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1351   gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1352   for (rego = gdbarch_data_registrary.registrations;
1353        rego != NULL;
1354        rego = rego->next)
1355     {
1356       if (rego->data->index < gdbarch->nr_data)
1357         gdbarch->data[rego->data->index] = rego->init ();
1358     }
1359 }
1360
1361
1362 /* Return the current value of the specified per-architecture
1363    data-pointer. */
1364
1365 void *
1366 gdbarch_data (data)
1367      struct gdbarch_data *data;
1368 {
1369   if (data->index >= current_gdbarch->nr_data)
1370     internal_error ("gdbarch_data: request for non-existant data.");
1371   return current_gdbarch->data[data->index];
1372 }
1373
1374
1375
1376 /* Keep a registrary of swaped data required by GDB modules. */
1377
1378 struct gdbarch_swap
1379 {
1380   void *swap;
1381   struct gdbarch_swap_registration *source;
1382   struct gdbarch_swap *next;
1383 };
1384
1385 struct gdbarch_swap_registration
1386 {
1387   void *data;
1388   unsigned long sizeof_data;
1389   gdbarch_swap_ftype *init;
1390   struct gdbarch_swap_registration *next;
1391 };
1392
1393 struct gdbarch_swap_registrary
1394 {
1395   int nr;
1396   struct gdbarch_swap_registration *registrations;
1397 };
1398
1399 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1400 {
1401   0, NULL,
1402 };
1403
1404 void
1405 register_gdbarch_swap (void *data,
1406                        unsigned long sizeof_data,
1407                        gdbarch_swap_ftype *init)
1408 {
1409   struct gdbarch_swap_registration **rego;
1410   for (rego = &gdbarch_swap_registrary.registrations;
1411        (*rego) != NULL;
1412        rego = &(*rego)->next);
1413   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1414   (*rego)->next = NULL;
1415   (*rego)->init = init;
1416   (*rego)->data = data;
1417   (*rego)->sizeof_data = sizeof_data;
1418 }
1419
1420
1421 static void
1422 init_gdbarch_swap (struct gdbarch *gdbarch)
1423 {
1424   struct gdbarch_swap_registration *rego;
1425   struct gdbarch_swap **curr = &gdbarch->swap;
1426   for (rego = gdbarch_swap_registrary.registrations;
1427        rego != NULL;
1428        rego = rego->next)
1429     {
1430       if (rego->data != NULL)
1431         {
1432           (*curr) = XMALLOC (struct gdbarch_swap);
1433           (*curr)->source = rego;
1434           (*curr)->swap = xmalloc (rego->sizeof_data);
1435           (*curr)->next = NULL;
1436           memset (rego->data, 0, rego->sizeof_data);
1437           curr = &(*curr)->next;
1438         }
1439       if (rego->init != NULL)
1440         rego->init ();
1441     }
1442 }
1443
1444 static void
1445 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1446 {
1447   struct gdbarch_swap *curr;
1448   for (curr = gdbarch->swap;
1449        curr != NULL;
1450        curr = curr->next)
1451     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1452 }
1453
1454 static void
1455 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1456 {
1457   struct gdbarch_swap *curr;
1458   for (curr = gdbarch->swap;
1459        curr != NULL;
1460        curr = curr->next)
1461     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1462 }
1463
1464
1465 /* Keep a registrary of the architectures known by GDB. */
1466
1467 struct gdbarch_init_registration
1468 {
1469   enum bfd_architecture bfd_architecture;
1470   gdbarch_init_ftype *init;
1471   struct gdbarch_list *arches;
1472   struct gdbarch_init_registration *next;
1473 };
1474
1475 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1476
1477 void
1478 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1479                        gdbarch_init_ftype *init)
1480 {
1481   struct gdbarch_init_registration **curr;
1482   const struct bfd_arch_info *bfd_arch_info;
1483   /* Check that BFD reconizes this architecture */
1484   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1485   if (bfd_arch_info == NULL)
1486     {
1487       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1488     }
1489   /* Check that we haven't seen this architecture before */
1490   for (curr = &gdbarch_init_registrary;
1491        (*curr) != NULL;
1492        curr = &(*curr)->next)
1493     {
1494       if (bfd_architecture == (*curr)->bfd_architecture)
1495         internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1496                bfd_arch_info->printable_name);
1497     }
1498   /* log it */
1499   if (gdbarch_debug)
1500     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1501                         bfd_arch_info->printable_name,
1502                         (long) init);
1503   /* Append it */
1504   (*curr) = XMALLOC (struct gdbarch_init_registration);
1505   (*curr)->bfd_architecture = bfd_architecture;
1506   (*curr)->init = init;
1507   (*curr)->arches = NULL;
1508   (*curr)->next = NULL;
1509 }
1510
1511
1512
1513 /* Look for an architecture using gdbarch_info.  Base search on only
1514    BFD_ARCH_INFO and BYTE_ORDER. */
1515
1516 struct gdbarch_list *
1517 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1518                              const struct gdbarch_info *info)
1519 {
1520   for (; arches != NULL; arches = arches->next)
1521     {
1522       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1523         continue;
1524       if (info->byte_order != arches->gdbarch->byte_order)
1525         continue;
1526       return arches;
1527     }
1528   return NULL;
1529 }
1530
1531
1532 /* Update the current architecture. Return ZERO if the update request
1533    failed. */
1534
1535 int
1536 gdbarch_update (struct gdbarch_info info)
1537 {
1538   struct gdbarch *new_gdbarch;
1539   struct gdbarch_list **list;
1540   struct gdbarch_init_registration *rego;
1541
1542   /* Fill in any missing bits. Most important is the bfd_architecture
1543      which is used to select the target architecture. */
1544   if (info.bfd_architecture == bfd_arch_unknown)
1545     {
1546       if (info.bfd_arch_info != NULL)
1547         info.bfd_architecture = info.bfd_arch_info->arch;
1548       else if (info.abfd != NULL)
1549         info.bfd_architecture = bfd_get_arch (info.abfd);
1550       /* FIXME - should query BFD for its default architecture. */
1551       else
1552         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1553     }
1554   if (info.bfd_arch_info == NULL)
1555     {
1556       if (target_architecture_auto && info.abfd != NULL)
1557         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1558       else
1559         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1560     }
1561   if (info.byte_order == 0)
1562     {
1563       if (target_byte_order_auto && info.abfd != NULL)
1564         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1565                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1566                            : 0);
1567       else
1568         info.byte_order = current_gdbarch->byte_order;
1569       /* FIXME - should query BFD for its default byte-order. */
1570     }
1571   /* A default for abfd? */
1572
1573   /* Find the target that knows about this architecture. */
1574   for (rego = gdbarch_init_registrary;
1575        rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1576        rego = rego->next);
1577   if (rego == NULL)
1578     {
1579       if (gdbarch_debug)
1580         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1581       return 0;
1582     }
1583
1584   if (gdbarch_debug)
1585     {
1586       fprintf_unfiltered (gdb_stdlog,
1587                           "gdbarch_update: info.bfd_architecture %d (%s)\n",
1588                           info.bfd_architecture,
1589                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1590       fprintf_unfiltered (gdb_stdlog,
1591                           "gdbarch_update: info.bfd_arch_info %s\n",
1592                           (info.bfd_arch_info != NULL
1593                            ? info.bfd_arch_info->printable_name
1594                            : "(null)"));
1595       fprintf_unfiltered (gdb_stdlog,
1596                           "gdbarch_update: info.byte_order %d (%s)\n",
1597                           info.byte_order,
1598                           (info.byte_order == BIG_ENDIAN ? "big"
1599                            : info.byte_order == LITTLE_ENDIAN ? "little"
1600                            : "default"));
1601       fprintf_unfiltered (gdb_stdlog,
1602                           "gdbarch_update: info.abfd 0x%lx\n",
1603                           (long) info.abfd);
1604       fprintf_unfiltered (gdb_stdlog,
1605                           "gdbarch_update: info.tdep_info 0x%lx\n",
1606                           (long) info.tdep_info);
1607     }
1608
1609   /* Ask the target for a replacement architecture. */
1610   new_gdbarch = rego->init (info, rego->arches);
1611
1612   /* Did the target like it?  No. Reject the change. */
1613   if (new_gdbarch == NULL)
1614     {
1615       if (gdbarch_debug)
1616         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1617       return 0;
1618     }
1619
1620   /* Did the architecture change?  No. Do nothing. */
1621   if (current_gdbarch == new_gdbarch)
1622     {
1623       if (gdbarch_debug)
1624         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1625                             (long) new_gdbarch,
1626                             new_gdbarch->bfd_arch_info->printable_name);
1627       return 1;
1628     }
1629
1630   /* Swap all data belonging to the old target out */
1631   swapout_gdbarch_swap (current_gdbarch);
1632
1633   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
1634   for (list = &rego->arches;
1635        (*list) != NULL;
1636        list = &(*list)->next)
1637     {
1638       if ((*list)->gdbarch == new_gdbarch)
1639         {
1640           if (gdbarch_debug)
1641             fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1642                                 (long) new_gdbarch,
1643                                 new_gdbarch->bfd_arch_info->printable_name);
1644           current_gdbarch = new_gdbarch;
1645           swapin_gdbarch_swap (new_gdbarch);
1646           return 1;
1647         }
1648     }
1649
1650   /* Append this new architecture to this targets list. */
1651   (*list) = XMALLOC (struct gdbarch_list);
1652   (*list)->next = NULL;
1653   (*list)->gdbarch = new_gdbarch;
1654
1655   /* Switch to this new architecture.  Dump it out. */
1656   current_gdbarch = new_gdbarch;
1657   if (gdbarch_debug)
1658     {
1659       fprintf_unfiltered (gdb_stdlog,
1660                           "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1661                           (long) new_gdbarch,
1662                           new_gdbarch->bfd_arch_info->printable_name);
1663       gdbarch_dump ();
1664     }
1665
1666   /* Check that the newly installed architecture is valid.  */
1667   verify_gdbarch (new_gdbarch);
1668
1669   /* Initialize the per-architecture memory (swap) areas.
1670      CURRENT_GDBARCH must be update before these modules are
1671      called. */
1672   init_gdbarch_swap (new_gdbarch);
1673
1674   /* Initialize the per-architecture data-pointer of all parties that
1675      registered an interest in this architecture.  CURRENT_GDBARCH
1676      must be updated before these modules are called. */
1677   init_gdbarch_data (new_gdbarch);
1678
1679   return 1;
1680 }
1681
1682
1683
1684 /* Functions to manipulate the endianness of the target.  */
1685
1686 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1687 /* compat - Catch old targets that expect a selectable byte-order to
1688    default to BIG_ENDIAN */
1689 #ifndef TARGET_BYTE_ORDER_DEFAULT
1690 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1691 #endif
1692 #endif
1693 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1694 #ifndef TARGET_BYTE_ORDER_DEFAULT
1695 /* compat - Catch old non byte-order selectable targets that do not
1696    define TARGET_BYTE_ORDER_DEFAULT and instead expect
1697    TARGET_BYTE_ORDER to be used as the default.  For targets that
1698    defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1699    below will get a strange compiler warning. */
1700 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1701 #endif
1702 #endif
1703 #ifndef TARGET_BYTE_ORDER_DEFAULT
1704 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1705 #endif
1706 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1707 int target_byte_order_auto = 1;
1708
1709 /* Chain containing the \"set endian\" commands.  */
1710 static struct cmd_list_element *endianlist = NULL;
1711
1712 /* Called by \`\`show endian''.  */
1713 static void
1714 show_endian (char *args, int from_tty)
1715 {
1716   char *msg =
1717     (TARGET_BYTE_ORDER_AUTO
1718      ? "The target endianness is set automatically (currently %s endian)\n"
1719      : "The target is assumed to be %s endian\n");
1720   printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1721 }
1722
1723 /* Called if the user enters \`\`set endian'' without an argument.  */
1724 static void
1725 set_endian (char *args, int from_tty)
1726 {
1727   printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1728   show_endian (args, from_tty);
1729 }
1730
1731 /* Called by \`\`set endian big''.  */
1732 static void
1733 set_endian_big (char *args, int from_tty)
1734 {
1735   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1736     {
1737       target_byte_order = BIG_ENDIAN;
1738       target_byte_order_auto = 0;
1739       if (GDB_MULTI_ARCH)
1740         {
1741           struct gdbarch_info info;
1742           memset (&info, 0, sizeof info);
1743           info.byte_order = BIG_ENDIAN;
1744           gdbarch_update (info);
1745         }
1746     }
1747   else
1748     {
1749       printf_unfiltered ("Byte order is not selectable.");
1750       show_endian (args, from_tty);
1751     }
1752 }
1753
1754 /* Called by \`\`set endian little''.  */
1755 static void
1756 set_endian_little (char *args, int from_tty)
1757 {
1758   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1759     {
1760       target_byte_order = LITTLE_ENDIAN;
1761       target_byte_order_auto = 0;
1762       if (GDB_MULTI_ARCH)
1763         {
1764           struct gdbarch_info info;
1765           memset (&info, 0, sizeof info);
1766           info.byte_order = LITTLE_ENDIAN;
1767           gdbarch_update (info);
1768         }
1769     }
1770   else
1771     {
1772       printf_unfiltered ("Byte order is not selectable.");
1773       show_endian (args, from_tty);
1774     }
1775 }
1776
1777 /* Called by \`\`set endian auto''.  */
1778 static void
1779 set_endian_auto (char *args, int from_tty)
1780 {
1781   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1782     {
1783       target_byte_order_auto = 1;
1784     }
1785   else
1786     {
1787       printf_unfiltered ("Byte order is not selectable.");
1788       show_endian (args, from_tty);
1789     }
1790 }
1791
1792 /* Set the endianness from a BFD.  */
1793 static void
1794 set_endian_from_file (bfd *abfd)
1795 {
1796   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1797     {
1798       int want;
1799
1800       if (bfd_big_endian (abfd))
1801         want = BIG_ENDIAN;
1802       else
1803         want = LITTLE_ENDIAN;
1804       if (TARGET_BYTE_ORDER_AUTO)
1805         target_byte_order = want;
1806       else if (TARGET_BYTE_ORDER != want)
1807         warning ("%s endian file does not match %s endian target.",
1808                  want == BIG_ENDIAN ? "big" : "little",
1809                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1810     }
1811   else
1812     {
1813       if (bfd_big_endian (abfd)
1814           ? TARGET_BYTE_ORDER != BIG_ENDIAN
1815           : TARGET_BYTE_ORDER == BIG_ENDIAN)
1816         warning ("%s endian file does not match %s endian target.",
1817                  bfd_big_endian (abfd) ? "big" : "little",
1818                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1819     }
1820 }
1821
1822
1823
1824 /* Functions to manipulate the architecture of the target */
1825
1826 enum set_arch { set_arch_auto, set_arch_manual };
1827
1828 int target_architecture_auto = 1;
1829 extern const struct bfd_arch_info bfd_default_arch_struct;
1830 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1831 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1832
1833 static void show_endian (char *, int);
1834 static void set_endian (char *, int);
1835 static void set_endian_big (char *, int);
1836 static void set_endian_little (char *, int);
1837 static void set_endian_auto (char *, int);
1838 static void set_endian_from_file (bfd *);
1839 static int arch_ok (const struct bfd_arch_info *arch);
1840 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1841 static void show_architecture (char *, int);
1842 static void set_architecture (char *, int);
1843 static void info_architecture (char *, int);
1844 static void set_architecture_from_file (bfd *);
1845
1846 /* Do the real work of changing the current architecture */
1847
1848 static int
1849 arch_ok (const struct bfd_arch_info *arch)
1850 {
1851   /* Should be performing the more basic check that the binary is
1852      compatible with GDB. */
1853   /* Check with the target that the architecture is valid. */
1854   return (target_architecture_hook == NULL
1855           || target_architecture_hook (arch));
1856 }
1857
1858 static void
1859 set_arch (const struct bfd_arch_info *arch,
1860           enum set_arch type)
1861 {
1862   switch (type)
1863     {
1864     case set_arch_auto:
1865       if (!arch_ok (arch))
1866         warning ("Target may not support %s architecture",
1867                  arch->printable_name);
1868       target_architecture = arch;
1869       break;
1870     case set_arch_manual:
1871       if (!arch_ok (arch))
1872         {
1873           printf_unfiltered ("Target does not support \`%s' architecture.\n",
1874                              arch->printable_name);
1875         }
1876       else
1877         {
1878           target_architecture_auto = 0;
1879           target_architecture = arch;
1880         }
1881       break;
1882     }
1883   if (gdbarch_debug)
1884     gdbarch_dump ();
1885 }
1886
1887 /* Called if the user enters \`\`show architecture'' without an argument. */
1888 static void
1889 show_architecture (char *args, int from_tty)
1890 {
1891   const char *arch;
1892   arch = TARGET_ARCHITECTURE->printable_name;
1893   if (target_architecture_auto)
1894     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1895   else
1896     printf_filtered ("The target architecture is assumed to be %s\n", arch);
1897 }
1898
1899 /* Called if the user enters \`\`set architecture'' with or without an
1900    argument. */
1901 static void
1902 set_architecture (char *args, int from_tty)
1903 {
1904   if (args == NULL)
1905     {
1906       printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1907     }
1908   else if (strcmp (args, "auto") == 0)
1909     {
1910       target_architecture_auto = 1;
1911     }
1912   else if (GDB_MULTI_ARCH)
1913     {
1914       const struct bfd_arch_info *arch = bfd_scan_arch (args);
1915       if (arch == NULL)
1916         printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1917       else
1918         {
1919           struct gdbarch_info info;
1920           memset (&info, 0, sizeof info);
1921           info.bfd_arch_info = arch;
1922           if (gdbarch_update (info))
1923             target_architecture_auto = 0;
1924           else
1925             printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1926         }
1927     }
1928   else
1929     {
1930       const struct bfd_arch_info *arch = bfd_scan_arch (args);
1931       if (arch != NULL)
1932         set_arch (arch, set_arch_manual);
1933       else
1934         printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1935     }
1936 }
1937
1938 /* Called if the user enters \`\`info architecture'' without an argument. */
1939 static void
1940 info_architecture (char *args, int from_tty)
1941 {
1942   enum bfd_architecture a;
1943   if (GDB_MULTI_ARCH)
1944     {
1945       if (gdbarch_init_registrary != NULL)
1946         {
1947           struct gdbarch_init_registration *rego;
1948           printf_filtered ("Available architectures are:\n");
1949           for (rego = gdbarch_init_registrary;
1950                rego != NULL;
1951                rego = rego->next)
1952             {
1953               const struct bfd_arch_info *ap;
1954               ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1955               if (ap != NULL)
1956                 {
1957                   do
1958                     {
1959                       printf_filtered (" %s", ap->printable_name);
1960                       ap = ap->next;
1961                     }
1962                   while (ap != NULL);
1963                   printf_filtered ("\n");
1964                 }
1965             }
1966         }
1967       else
1968         {
1969           printf_filtered ("There are no available architectures.\n");
1970         }
1971       return;
1972     }
1973   printf_filtered ("Available architectures are:\n");
1974   for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1975     {
1976       const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1977       if (ap != NULL)
1978         {
1979           do
1980             {
1981               printf_filtered (" %s", ap->printable_name);
1982               ap = ap->next;
1983             }
1984           while (ap != NULL);
1985           printf_filtered ("\n");
1986         }
1987     }
1988 }
1989
1990 /* Set the architecture from arch/machine */
1991 void
1992 set_architecture_from_arch_mach (arch, mach)
1993      enum bfd_architecture arch;
1994      unsigned long mach;
1995 {
1996   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1997   if (wanted != NULL)
1998     set_arch (wanted, set_arch_manual);
1999   else
2000     internal_error ("gdbarch: hardwired architecture/machine not reconized");
2001 }
2002
2003 /* Set the architecture from a BFD */
2004 static void
2005 set_architecture_from_file (bfd *abfd)
2006 {
2007   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
2008   if (target_architecture_auto)
2009     {
2010       set_arch (wanted, set_arch_auto);
2011     }
2012   else if (wanted != target_architecture)
2013     {
2014       warning ("%s architecture file may be incompatible with %s target.",
2015                wanted->printable_name,
2016                target_architecture->printable_name);
2017     }
2018 }
2019
2020
2021 /* Misc helper functions for targets. */
2022
2023 int
2024 frame_num_args_unknown (fi)
2025      struct frame_info *fi;
2026 {
2027   return -1;
2028 }
2029
2030
2031 int
2032 generic_register_convertible_not (num)
2033      int num;
2034 {
2035   return 0;
2036 }
2037
2038
2039 /* Disassembler */
2040
2041 /* Pointer to the target-dependent disassembly function.  */
2042 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2043 disassemble_info tm_print_insn_info;
2044
2045
2046
2047 /* Set the dynamic target-system-dependant parameters (architecture,
2048    byte-order) using information found in the BFD */
2049
2050 void
2051 set_gdbarch_from_file (abfd)
2052      bfd *abfd;
2053 {
2054   if (GDB_MULTI_ARCH)
2055     {
2056       struct gdbarch_info info;
2057       memset (&info, 0, sizeof info);
2058       info.abfd = abfd;
2059       gdbarch_update (info);
2060       return;
2061     }
2062   set_architecture_from_file (abfd);
2063   set_endian_from_file (abfd);
2064 }
2065
2066
2067 /* Initialize the current architecture.  */
2068 void
2069 initialize_current_architecture ()
2070 {
2071   if (GDB_MULTI_ARCH)
2072     {
2073       struct gdbarch_init_registration *rego;
2074       const struct bfd_arch_info *chosen = NULL;
2075       for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
2076         {
2077           const struct bfd_arch_info *ap
2078             = bfd_lookup_arch (rego->bfd_architecture, 0);
2079
2080           /* Choose the first architecture alphabetically.  */
2081           if (chosen == NULL
2082               || strcmp (ap->printable_name, chosen->printable_name) < 0)
2083             chosen = ap;
2084         }
2085
2086       if (chosen != NULL)
2087         {
2088           struct gdbarch_info info;
2089           memset (&info, 0, sizeof info);
2090           info.bfd_arch_info = chosen;
2091           gdbarch_update (info);
2092         }
2093     }
2094 }
2095
2096 extern void _initialize_gdbarch (void);
2097 void
2098 _initialize_gdbarch ()
2099 {
2100   struct cmd_list_element *c;
2101
2102   add_prefix_cmd ("endian", class_support, set_endian,
2103                   "Set endianness of target.",
2104                   &endianlist, "set endian ", 0, &setlist);
2105   add_cmd ("big", class_support, set_endian_big,
2106            "Set target as being big endian.", &endianlist);
2107   add_cmd ("little", class_support, set_endian_little,
2108            "Set target as being little endian.", &endianlist);
2109   add_cmd ("auto", class_support, set_endian_auto,
2110            "Select target endianness automatically.", &endianlist);
2111   add_cmd ("endian", class_support, show_endian,
2112            "Show endianness of target.", &showlist);
2113
2114   add_cmd ("architecture", class_support, set_architecture,
2115            "Set architecture of target.", &setlist);
2116   add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
2117   add_cmd ("architecture", class_support, show_architecture,
2118            "Show architecture of target.", &showlist);
2119   add_cmd ("architecture", class_support, info_architecture,
2120            "List supported target architectures", &infolist);
2121
2122   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2123   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2124   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2125   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2126   tm_print_insn_info.print_address_func = dis_asm_print_address;
2127
2128   add_show_from_set (add_set_cmd ("arch",
2129                                   class_maintenance,
2130                                   var_zinteger,
2131                                   (char *)&gdbarch_debug,
2132                                   "Set architecture debugging.\n\\
2133 When non-zero, architecture debugging is enabled.", &setdebuglist),
2134                      &showdebuglist);
2135   c = add_set_cmd ("archdebug",
2136                    class_maintenance,
2137                    var_zinteger,
2138                    (char *)&gdbarch_debug,
2139                    "Set architecture debugging.\n\\
2140 When non-zero, architecture debugging is enabled.", &setlist);
2141
2142   deprecate_cmd (c, "set debug arch");
2143   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2144 }
2145 EOF
2146
2147 # close things off
2148 exec 1>&2
2149 #../move-if-change new-gdbarch.c gdbarch.c
2150 compare_new gdbarch.c