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 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 EOF
 330   grep -v '^#'
 331 }
 332
 333
 334 # dump it out
 335 if true
 336 then
 337     exec > new-gdbarch
 338     function_list | while do_read # eval read $read
 339     do
 340         cat <<EOF
 341 ${class} ${macro}(${actual})
 342   ${returntype} ${function} ($formal)${attrib}
 343     level=${level}
 344     startup=${startup}
 345     default=${default}
 346     invalid_p=${invalid_p}
 347     valid_p=${valid_p}
 348     fmt=${fmt}
 349     print=${print}
 350     print_p=${print_p}
 351     description=${description}
 352 EOF
 353         if class_is_predicate_p && default_is_fallback_p
 354         then
 355             echo "Error: predicate function can not have a non- multi-arch default" 1>&2
 356             kill $$
 357             exit 1
 358         fi
 359     done
 360     exec 1>&2
 361 fi
 362
 363 copyright ()
 364 {
 365 cat <<EOF
 366 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
 367
 368 /* Dynamic architecture support for GDB, the GNU debugger.
 369    Copyright 1998-1999, Free Software Foundation, Inc.
 370
 371    This file is part of GDB.
 372
 373    This program is free software; you can redistribute it and/or modify
 374    it under the terms of the GNU General Public License as published by
 375    the Free Software Foundation; either version 2 of the License, or
 376    (at your option) any later version.
 377
 378    This program is distributed in the hope that it will be useful,
 379    but WITHOUT ANY WARRANTY; without even the implied warranty of
 380    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 381    GNU General Public License for more details.
 382
 383    You should have received a copy of the GNU General Public License
 384    along with this program; if not, write to the Free Software
 385    Foundation, Inc., 59 Temple Place - Suite 330,
 386    Boston, MA 02111-1307, USA.  */
 387
 388 /* This file was created with the aid of \`\`gdbarch.sh''.
 389
 390    The bourn shell script \`\`gdbarch.sh'' creates the files
 391    \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
 392    against the existing \`\`gdbarch.[hc]''.  Any differences found
 393    being reported.
 394
 395    If editing this file, please also run gdbarch.sh and merge any
 396    changes into that script. Conversely, when makeing sweeping changes
 397    to this file, modifying gdbarch.sh and using its output may prove
 398    easier. */
 399
 400 EOF
 401 }
 402
 403 #
 404 # The .h file
 405 #
 406
 407 exec > new-gdbarch.h
 408 copyright
 409 cat <<EOF
 410 #ifndef GDBARCH_H
 411 #define GDBARCH_H
 412
 413 struct frame_info;
 414 struct value;
 415
 416
 417 #ifndef GDB_MULTI_ARCH
 418 #define GDB_MULTI_ARCH 0
 419 #endif
 420
 421 extern struct gdbarch *current_gdbarch;
 422
 423
 424 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
 425    macro */
 426
 427
 428 /* If any of the following are defined, the target wasn't correctly
 429    converted. */
 430
 431 #if GDB_MULTI_ARCH
 432 #if defined (EXTRA_FRAME_INFO)
 433 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
 434 #endif
 435 #endif
 436
 437 #if GDB_MULTI_ARCH
 438 #if defined (FRAME_FIND_SAVED_REGS)
 439 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
 440 #endif
 441 #endif
 442 EOF
 443
 444 # function typedef's
 445 echo ""
 446 echo ""
 447 echo "/* The following are pre-initialized by GDBARCH. */"
 448 function_list | while do_read # eval read $read
 449 do
 450     if class_is_info_p
 451     then
 452         echo ""
 453         echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
 454         echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
 455         echo "#if GDB_MULTI_ARCH"
 456         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
 457         echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
 458         echo "#endif"
 459         echo "#endif"
 460     fi
 461 done
 462
 463 # function typedef's
 464 echo ""
 465 echo ""
 466 echo "/* The following are initialized by the target dependant code. */"
 467 function_list | while do_read # eval read $read
 468 do
 469     if class_is_predicate_p
 470     then
 471         echo ""
 472         echo "#if defined (${macro})"
 473         echo "/* Legacy for systems yet to multi-arch ${macro} */"
 474 #       echo "#if (GDB_MULTI_ARCH <= 2) && defined (${macro})"
 475         echo "#define ${macro}_P() (1)"
 476         echo "#endif"
 477         echo ""
 478         echo "/* Default predicate for non- multi-arch targets. */"
 479         echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro}_P)"
 480         echo "#define ${macro}_P() (0)"
 481         echo "#endif"
 482         echo ""
 483         echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
 484         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro}_P)"
 485         echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
 486         echo "#endif"
 487     fi
 488     if class_is_variable_p
 489     then
 490         if default_is_fallback_p || class_is_predicate_p
 491         then
 492             echo ""
 493             echo "/* Default (value) for non- multi-arch platforms. */"
 494             echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
 495             echo "#define ${macro} (${default})"
 496             echo "#endif"
 497         fi
 498         echo ""
 499         echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
 500         echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
 501         echo "#if GDB_MULTI_ARCH"
 502         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
 503         echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
 504         echo "#endif"
 505         echo "#endif"
 506     fi
 507     if class_is_function_p
 508     then
 509         if default_is_fallback_p || class_is_predicate_p
 510         then
 511             echo ""
 512             echo "/* Default (function) for non- multi-arch platforms. */"
 513             echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
 514             if [ "${default}" = "0" ]
 515             then
 516                 echo "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)"
 517             else
 518                 echo "#define ${macro}(${actual}) (${default} (${actual}))"
 519             fi
 520             echo "#endif"
 521         fi
 522         echo ""
 523         echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
 524         if [ "${formal}" = "void" ]
 525         then
 526           echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
 527         else
 528           echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
 529         fi
 530         echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
 531         echo "#if GDB_MULTI_ARCH"
 532         echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
 533         if [ "${actual}" = "" ]
 534         then
 535           echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
 536         elif [ "${actual}" = "-" ]
 537         then
 538           echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
 539         else
 540           echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
 541         fi
 542         echo "#endif"
 543         echo "#endif"
 544     fi
 545 done
 546
 547 # close it off
 548 cat <<EOF
 549
 550 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
 551
 552
 553 /* Mechanism for co-ordinating the selection of a specific
 554    architecture.
 555
 556    GDB targets (*-tdep.c) can register an interest in a specific
 557    architecture.  Other GDB components can register a need to maintain
 558    per-architecture data.
 559
 560    The mechanisms below ensures that there is only a loose connection
 561    between the set-architecture command and the various GDB
 562    components.  Each component can independantly register their need
 563    to maintain architecture specific data with gdbarch.
 564
 565    Pragmatics:
 566
 567    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
 568    didn't scale.
 569
 570    The more traditional mega-struct containing architecture specific
 571    data for all the various GDB components was also considered.  Since
 572    GDB is built from a variable number of (fairly independant)
 573    components it was determined that the global aproach was not
 574    applicable. */
 575
 576
 577 /* Register a new architectural family with GDB.
 578
 579    Register support for the specified ARCHITECTURE with GDB.  When
 580    gdbarch determines that the specified architecture has been
 581    selected, the corresponding INIT function is called.
 582
 583    --
 584
 585    The INIT function takes two parameters: INFO which contains the
 586    information available to gdbarch about the (possibly new)
 587    architecture; ARCHES which is a list of the previously created
 588    \`\`struct gdbarch'' for this architecture.
 589
 590    The INIT function parameter INFO shall, as far as possible, be
 591    pre-initialized with information obtained from INFO.ABFD or
 592    previously selected architecture (if similar).  INIT shall ensure
 593    that the INFO.BYTE_ORDER is non-zero.
 594
 595    The INIT function shall return any of: NULL - indicating that it
 596    doesn't reconize the selected architecture; an existing \`\`struct
 597    gdbarch'' from the ARCHES list - indicating that the new
 598    architecture is just a synonym for an earlier architecture (see
 599    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
 600    - that describes the selected architecture (see
 601    gdbarch_alloc()). */
 602
 603 struct gdbarch_list
 604 {
 605   struct gdbarch *gdbarch;
 606   struct gdbarch_list *next;
 607 };
 608
 609 struct gdbarch_info
 610 {
 611   /* Use default: bfd_arch_unknown (ZERO). */
 612   enum bfd_architecture bfd_architecture;
 613
 614   /* Use default: NULL (ZERO). */
 615   const struct bfd_arch_info *bfd_arch_info;
 616
 617   /* Use default: 0 (ZERO). */
 618   int byte_order;
 619
 620   /* Use default: NULL (ZERO). */
 621   bfd *abfd;
 622
 623   /* Use default: NULL (ZERO). */
 624   struct gdbarch_tdep_info *tdep_info;
 625 };
 626
 627 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
 628
 629 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 630
 631
 632 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 633    matches the information provided by INFO. */
 634
 635 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
 636
 637
 638 /* Helper function.  Create a preliminary \`\`struct gdbarch''.  Perform
 639    basic initialization using values obtained from the INFO andTDEP
 640    parameters.  set_gdbarch_*() functions are called to complete the
 641    initialization of the object. */
 642
 643 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 644
 645
 646 /* Helper function.  Free a partially-constructed \`\`struct gdbarch''.  */
 647 extern void gdbarch_free (struct gdbarch *);
 648
 649
 650 /* Helper function. Force an update of the current architecture.  Used
 651    by legacy targets that have added their own target specific
 652    architecture manipulation commands.
 653
 654    The INFO parameter shall be fully initialized (\`\`memset (&INFO,
 655    sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
 656    called.  gdbarch_update() shall initialize any \`\`default'' fields
 657    using information obtained from the previous architecture or
 658    INFO.ABFD (if specified) before calling the corresponding
 659    architectures INIT function. */
 660
 661 extern int gdbarch_update (struct gdbarch_info info);
 662
 663
 664
 665 /* Register per-architecture data-pointer.
 666
 667    Reserve space for a per-architecture data-pointer.  An identifier
 668    for the reserved data-pointer is returned.  That identifer should
 669    be saved in a local static.
 670
 671    When a new architecture is selected, INIT() is called.  When a
 672    previous architecture is re-selected, the per-architecture
 673    data-pointer for that previous architecture is restored (INIT() is
 674    not called).
 675
 676    INIT() shall return the initial value for the per-architecture
 677    data-pointer for the current architecture.
 678
 679    Multiple registrarants for any architecture are allowed (and
 680    strongly encouraged).  */
 681
 682 typedef void *(gdbarch_data_ftype) (void);
 683 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
 684
 685 /* Return the value of the per-architecture data-pointer for the
 686    current architecture. */
 687
 688 extern void *gdbarch_data (struct gdbarch_data*);
 689
 690
 691
 692 /* Register per-architecture memory region.
 693
 694    Provide a memory-region swap mechanism.  Per-architecture memory
 695    region are created.  These memory regions are swapped whenever the
 696    architecture is changed.  For a new architecture, the memory region
 697    is initialized with zero (0) and the INIT function is called.
 698
 699    Memory regions are swapped / initialized in the order that they are
 700    registered.  NULL DATA and/or INIT values can be specified.
 701
 702    New code should use register_gdbarch_data(). */
 703
 704 typedef void (gdbarch_swap_ftype) (void);
 705 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
 706 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 707
 708
 709
 710 /* The target-system-dependant byte order is dynamic */
 711
 712 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 713    is selectable at runtime.  The user can use the \`\`set endian''
 714    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 715    target_byte_order should be auto-detected (from the program image
 716    say). */
 717
 718 #if GDB_MULTI_ARCH
 719 /* Multi-arch GDB is always bi-endian. */
 720 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 721 #endif
 722
 723 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 724 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 725    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 726 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 727 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 728 #else
 729 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 730 #endif
 731 #endif
 732
 733 extern int target_byte_order;
 734 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 735 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 736    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 737 #undef TARGET_BYTE_ORDER
 738 #endif
 739 #ifndef TARGET_BYTE_ORDER
 740 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 741 #endif
 742
 743 extern int target_byte_order_auto;
 744 #ifndef TARGET_BYTE_ORDER_AUTO
 745 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 746 #endif
 747
 748
 749
 750 /* The target-system-dependant BFD architecture is dynamic */
 751
 752 extern int target_architecture_auto;
 753 #ifndef TARGET_ARCHITECTURE_AUTO
 754 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 755 #endif
 756
 757 extern const struct bfd_arch_info *target_architecture;
 758 #ifndef TARGET_ARCHITECTURE
 759 #define TARGET_ARCHITECTURE (target_architecture + 0)
 760 #endif
 761
 762 /* Notify the target dependant backend of a change to the selected
 763    architecture. A zero return status indicates that the target did
 764    not like the change. */
 765
 766 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
 767
 768
 769
 770 /* The target-system-dependant disassembler is semi-dynamic */
 771
 772 #include "dis-asm.h"            /* Get defs for disassemble_info */
 773
 774 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
 775                                 unsigned int len, disassemble_info *info);
 776
 777 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
 778                                   disassemble_info *info);
 779
 780 extern void dis_asm_print_address (bfd_vma addr,
 781                                    disassemble_info *info);
 782
 783 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
 784 extern disassemble_info tm_print_insn_info;
 785 #ifndef TARGET_PRINT_INSN
 786 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
 787 #endif
 788 #ifndef TARGET_PRINT_INSN_INFO
 789 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
 790 #endif
 791
 792
 793
 794 /* Explicit test for D10V architecture.
 795    USE of these macro's is *STRONGLY* discouraged. */
 796
 797 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
 798
 799
 800 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
 801 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
 802 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
 803 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
 804 #else
 805 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
 806 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
 807 #endif
 808 #endif
 809
 810
 811 /* Set the dynamic target-system-dependant parameters (architecture,
 812    byte-order, ...) using information found in the BFD */
 813
 814 extern void set_gdbarch_from_file (bfd *);
 815
 816
 817 /* Explicitly set the dynamic target-system-dependant parameters based
 818    on bfd_architecture and machine. */
 819
 820 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
 821
 822
 823 /* Initialize the current architecture to the "first" one we find on
 824    our list.  */
 825
 826 extern void initialize_current_architecture (void);
 827
 828 /* Helper function for targets that don't know how my arguments are
 829    being passed */
 830
 831 extern int frame_num_args_unknown (struct frame_info *fi);
 832
 833
 834 /* gdbarch trace variable */
 835 extern int gdbarch_debug;
 836
 837 extern void gdbarch_dump (void);
 838
 839 #endif
 840 EOF
 841 exec 1>&2
 842 #../move-if-change new-gdbarch.h gdbarch.h
 843 compare_new gdbarch.h
 844
 845
 846 #
 847 # C file
 848 #
 849
 850 exec > new-gdbarch.c
 851 copyright
 852 cat <<EOF
 853
 854 #include "defs.h"
 855 #include "arch-utils.h"
 856
 857 #if GDB_MULTI_ARCH
 858 #include "gdbcmd.h"
 859 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
 860 #else
 861 /* Just include everything in sight so that the every old definition
 862    of macro is visible. */
 863 #include "gdb_string.h"
 864 #include <ctype.h>
 865 #include "symtab.h"
 866 #include "frame.h"
 867 #include "inferior.h"
 868 #include "breakpoint.h"
 869 #include "gdb_wait.h"
 870 #include "gdbcore.h"
 871 #include "gdbcmd.h"
 872 #include "target.h"
 873 #include "gdbthread.h"
 874 #include "annotate.h"
 875 #include "symfile.h"            /* for overlay functions */
 876 #endif
 877 #include "symcat.h"
 878
 879
 880 /* Static function declarations */
 881
 882 static void verify_gdbarch (struct gdbarch *gdbarch);
 883 static void init_gdbarch_data (struct gdbarch *);
 884 static void init_gdbarch_swap (struct gdbarch *);
 885 static void swapout_gdbarch_swap (struct gdbarch *);
 886 static void swapin_gdbarch_swap (struct gdbarch *);
 887
 888 /* Convenience macro for allocting typesafe memory. */
 889
 890 #ifndef XMALLOC
 891 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
 892 #endif
 893
 894
 895 /* Non-zero if we want to trace architecture code.  */
 896
 897 #ifndef GDBARCH_DEBUG
 898 #define GDBARCH_DEBUG 0
 899 #endif
 900 int gdbarch_debug = GDBARCH_DEBUG;
 901
 902 EOF
 903
 904 # gdbarch open the gdbarch object
 905 echo ""
 906 echo "/* Maintain the struct gdbarch object */"
 907 echo ""
 908 echo "struct gdbarch"
 909 echo "{"
 910 echo "  /* basic architectural information */"
 911 function_list | while do_read # eval read $read
 912 do
 913     if class_is_info_p
 914     then
 915         echo "  ${returntype} ${function};"
 916     fi
 917 done
 918 echo ""
 919 echo "  /* target specific vector. */"
 920 echo "  struct gdbarch_tdep *tdep;"
 921 echo ""
 922 echo "  /* per-architecture data-pointers */"
 923 echo "  int nr_data;"
 924 echo "  void **data;"
 925 echo ""
 926 echo "  /* per-architecture swap-regions */"
 927 echo "  struct gdbarch_swap *swap;"
 928 echo ""
 929 cat <<EOF
 930   /* Multi-arch values.
 931
 932      When extending this structure you must:
 933
 934      Add the field below.
 935
 936      Declare set/get functions and define the corresponding
 937      macro in gdbarch.h.
 938
 939      gdbarch_alloc(): If zero/NULL is not a suitable default,
 940      initialize the new field.
 941
 942      verify_gdbarch(): Confirm that the target updated the field
 943      correctly.
 944
 945      gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
 946      field is dumped out
 947
 948      \`\`startup_gdbarch()'': Append an initial value to the static
 949      variable (base values on the host's c-type system).
 950
 951      get_gdbarch(): Implement the set/get functions (probably using
 952      the macro's as shortcuts).
 953
 954      */
 955
 956 EOF
 957 function_list | while do_read # eval read $read
 958 do
 959     if class_is_variable_p
 960     then
 961         echo "  ${returntype} ${function};"
 962     elif class_is_function_p
 963     then
 964         echo "  gdbarch_${function}_ftype *${function}${attrib};"
 965     fi
 966 done
 967 echo "};"
 968
 969 # A pre-initialized vector
 970 echo ""
 971 echo ""
 972 cat <<EOF
 973 /* The default architecture uses host values (for want of a better
 974    choice). */
 975 EOF
 976 echo ""
 977 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
 978 echo ""
 979 echo "struct gdbarch startup_gdbarch = {"
 980 echo "  /* basic architecture information */"
 981 function_list | while do_read # eval read $read
 982 do
 983     if class_is_info_p
 984     then
 985         echo "  ${startup},"
 986     fi
 987 done
 988 cat <<EOF
 989   /* target specific vector */
 990   NULL,
 991   /*per-architecture data-pointers and swap regions */
 992   0, NULL, NULL,
 993   /* Multi-arch values */
 994 EOF
 995 function_list | while do_read # eval read $read
 996 do
 997     if class_is_function_p || class_is_variable_p
 998     then
 999         echo "  ${startup},"
1000     fi
1001 done
1002 cat <<EOF
1003   /* startup_gdbarch() */
1004 };
1005 struct gdbarch *current_gdbarch = &startup_gdbarch;
1006 EOF
1007
1008 # Create a new gdbarch struct
1009 echo ""
1010 echo ""
1011 cat <<EOF
1012 /* Create a new \`\`struct gdbarch'' based in information provided by
1013    \`\`struct gdbarch_info''. */
1014 EOF
1015 echo ""
1016 cat <<EOF
1017 struct gdbarch *
1018 gdbarch_alloc (const struct gdbarch_info *info,
1019                struct gdbarch_tdep *tdep)
1020 {
1021   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1022   memset (gdbarch, 0, sizeof (*gdbarch));
1023
1024   gdbarch->tdep = tdep;
1025 EOF
1026 echo ""
1027 function_list | while do_read # eval read $read
1028 do
1029     if class_is_info_p
1030     then
1031         echo "  gdbarch->${function} = info->${function};"
1032     fi
1033 done
1034 echo ""
1035 echo "  /* Force the explicit initialization of these. */"
1036 function_list | while do_read # eval read $read
1037 do
1038     if class_is_function_p || class_is_variable_p
1039     then
1040         if [ "${default}" != "" -a "${default}" != "0" ]
1041         then
1042           echo "  gdbarch->${function} = ${default};"
1043         fi
1044     fi
1045 done
1046 cat <<EOF
1047   /* gdbarch_alloc() */
1048
1049   return gdbarch;
1050 }
1051 EOF
1052
1053 # Free a gdbarch struct.
1054 echo ""
1055 echo ""
1056 cat <<EOF
1057 /* Free a gdbarch struct.  This should never happen in normal
1058    operation --- once you've created a gdbarch, you keep it around.
1059    However, if an architecture's init function encounters an error
1060    building the structure, it may need to clean up a partially
1061    constructed gdbarch.  */
1062 void
1063 gdbarch_free (struct gdbarch *arch)
1064 {
1065   /* At the moment, this is trivial.  */
1066   free (arch);
1067 }
1068 EOF
1069
1070 # verify a new architecture
1071 echo ""
1072 echo ""
1073 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1074 echo ""
1075 cat <<EOF
1076 static void
1077 verify_gdbarch (struct gdbarch *gdbarch)
1078 {
1079   /* Only perform sanity checks on a multi-arch target. */
1080   if (GDB_MULTI_ARCH <= 0)
1081     return;
1082   /* fundamental */
1083   if (gdbarch->byte_order == 0)
1084     internal_error ("verify_gdbarch: byte-order unset");
1085   if (gdbarch->bfd_arch_info == NULL)
1086     internal_error ("verify_gdbarch: bfd_arch_info unset");
1087   /* Check those that need to be defined for the given multi-arch level. */
1088 EOF
1089 function_list | while do_read # eval read $read
1090 do
1091     if class_is_function_p || class_is_variable_p
1092     then
1093         if [ "${invalid_p}" = "0" ]
1094         then
1095             echo "  /* Skip verify of ${function}, invalid_p == 0 */"
1096         elif class_is_predicate_p
1097         then
1098             echo "  /* Skip verify of ${function}, has predicate */"
1099         elif [ "${invalid_p}" ]
1100         then
1101             echo "  if ((GDB_MULTI_ARCH >= ${level})"
1102             echo "      && (${invalid_p}))"
1103             echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1104         elif [ "${default}" ]
1105         then
1106             echo "  if ((GDB_MULTI_ARCH >= ${level})"
1107             echo "      && (gdbarch->${function} == ${default}))"
1108             echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1109         fi
1110     fi
1111 done
1112 cat <<EOF
1113 }
1114 EOF
1115
1116 # dump the structure
1117 echo ""
1118 echo ""
1119 echo "/* Print out the details of the current architecture. */"
1120 echo ""
1121 cat <<EOF
1122 void
1123 gdbarch_dump (void)
1124 {
1125 EOF
1126 function_list | while do_read # eval read $read
1127 do
1128     if class_is_function_p
1129     then
1130         echo "  fprintf_unfiltered (gdb_stdlog,"
1131         echo "                      \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1132         echo "                      (long) current_gdbarch->${function}"
1133         echo "                      /*${macro} ()*/);"
1134     else
1135         if [ "${print_p}" = "#" ]
1136         then
1137           echo "#ifdef ${macro}"
1138           echo "  fprintf_unfiltered (gdb_stdlog,"
1139           echo "                      \"gdbarch_update: ${macro} = ${fmt}\\n\","
1140           echo "                      ${print});"
1141           echo "#endif"
1142         elif [ "${print_p}" ]
1143         then
1144           echo "  if (${print_p})"
1145           echo "    fprintf_unfiltered (gdb_stdlog,"
1146           echo "                        \"gdbarch_update: ${macro} = ${fmt}\\n\","
1147           echo "                        ${print});"
1148         else
1149           echo "  fprintf_unfiltered (gdb_stdlog,"
1150           echo "                      \"gdbarch_update: ${macro} = ${fmt}\\n\","
1151           echo "                      ${print});"
1152         fi
1153     fi
1154 done
1155 echo "}"
1156
1157
1158 # GET/SET
1159 echo ""
1160 cat <<EOF
1161 struct gdbarch_tdep *
1162 gdbarch_tdep (struct gdbarch *gdbarch)
1163 {
1164   if (gdbarch_debug >= 2)
1165     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1166   return gdbarch->tdep;
1167 }
1168 EOF
1169 echo ""
1170 function_list | while do_read # eval read $read
1171 do
1172     if class_is_predicate_p
1173     then
1174         echo ""
1175         echo "int"
1176         echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1177         echo "{"
1178         if [ "${valid_p}" ]
1179         then
1180             echo "  return ${valid_p};"
1181         else
1182             echo "#error \"gdbarch_${function}_p: not defined\""
1183         fi
1184         echo "}"
1185     fi
1186     if class_is_function_p
1187     then
1188         echo ""
1189         echo "${returntype}"
1190         if [ "${formal}" = "void" ]
1191         then
1192           echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1193         else
1194           echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1195         fi
1196         echo "{"
1197         echo "  if (gdbarch->${function} == 0)"
1198         echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1199         echo "  if (gdbarch_debug >= 2)"
1200         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1201         test "${actual}" = "-" && actual=""
1202         if [ "${returntype}" = "void" ]
1203         then
1204           echo "  gdbarch->${function} (${actual});"
1205         else
1206           echo "  return gdbarch->${function} (${actual});"
1207         fi
1208         echo "}"
1209         echo ""
1210         echo "void"
1211         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1212         echo "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})"
1213         echo "{"
1214         echo "  gdbarch->${function} = ${function};"
1215         echo "}"
1216     elif class_is_variable_p
1217     then
1218         echo ""
1219         echo "${returntype}"
1220         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1221         echo "{"
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