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