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