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