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