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