gdb/gdbarch.sh

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