gdb/gdbarch.sh

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