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