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