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     if [ ${returntype} == "void" ]
1232     then
1233         echo "#if defined (${macro}) && GDB_MULTI_ARCH"
1234         echo "  /* Macro might contain \`[{}]' when not multi-arch */"
1235     else
1236         echo "#ifdef ${macro}"
1237     fi
1238     if class_is_function_p
1239     then
1240         echo "  fprintf_unfiltered (file,"
1241         echo "                      \"gdbarch_dump: %s # %s\\n\","
1242         echo "                      \"${macro}(${actual})\","
1243         echo "                      XSTRING (${macro} (${actual})));"
1244     else
1245         echo "  fprintf_unfiltered (file,"
1246         echo "                      \"gdbarch_dump: ${macro} # %s\\n\","
1247         echo "                      XSTRING (${macro}));"
1248     fi
1249     echo "#endif"
1250 done
1251 function_list | while do_read
1252 do
1253     echo "#ifdef ${macro}"
1254     if [ "${print_p}" = "()" ]
1255     then
1256         echo "  gdbarch_dump_${function} (current_gdbarch);"
1257     elif [ "${print_p}" = "0" ]
1258     then
1259         echo "  /* skip print of ${macro}, print_p == 0. */"
1260     elif [ "${print_p}" ]
1261     then
1262         echo "  if (${print_p})"
1263         echo "    fprintf_unfiltered (file,"
1264         echo "                        \"gdbarch_dump: ${macro} = ${fmt}\\n\","
1265         echo "                        ${print});"
1266     elif class_is_function_p
1267     then
1268         echo "  if (GDB_MULTI_ARCH)"
1269         echo "    fprintf_unfiltered (file,"
1270         echo "                        \"gdbarch_dump: ${macro} = 0x%08lx\\n\","
1271         echo "                        (long) current_gdbarch->${function}"
1272         echo "                        /*${macro} ()*/);"
1273     else
1274         echo "  fprintf_unfiltered (file,"
1275         echo "                      \"gdbarch_dump: ${macro} = ${fmt}\\n\","
1276         echo "                      ${print});"
1277     fi
1278     echo "#endif"
1279 done
1280 cat <<EOF
1281   if (current_gdbarch->dump_tdep != NULL)
1282     current_gdbarch->dump_tdep (current_gdbarch, file);
1283 }
1284 EOF
1285
1286
1287 # GET/SET
1288 echo ""
1289 cat <<EOF
1290 struct gdbarch_tdep *
1291 gdbarch_tdep (struct gdbarch *gdbarch)
1292 {
1293   if (gdbarch_debug >= 2)
1294     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1295   return gdbarch->tdep;
1296 }
1297 EOF
1298 echo ""
1299 function_list | while do_read # eval read $read
1300 do
1301     if class_is_predicate_p
1302     then
1303         echo ""
1304         echo "int"
1305         echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1306         echo "{"
1307         if [ "${valid_p}" ]
1308         then
1309             echo "  return ${valid_p};"
1310         else
1311             echo "#error \"gdbarch_${function}_p: not defined\""
1312         fi
1313         echo "}"
1314     fi
1315     if class_is_function_p
1316     then
1317         echo ""
1318         echo "${returntype}"
1319         if [ "${formal}" = "void" ]
1320         then
1321           echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1322         else
1323           echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1324         fi
1325         echo "{"
1326         echo "  if (gdbarch->${function} == 0)"
1327         echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1328         echo "  if (gdbarch_debug >= 2)"
1329         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1330         test "${actual}" = "-" && actual=""
1331         if [ "${returntype}" = "void" ]
1332         then
1333           echo "  gdbarch->${function} (${actual});"
1334         else
1335           echo "  return gdbarch->${function} (${actual});"
1336         fi
1337         echo "}"
1338         echo ""
1339         echo "void"
1340         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1341         echo "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})"
1342         echo "{"
1343         echo "  gdbarch->${function} = ${function};"
1344         echo "}"
1345     elif class_is_variable_p
1346     then
1347         echo ""
1348         echo "${returntype}"
1349         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1350         echo "{"
1351         if [ "${invalid_p}" = "0" ]
1352         then
1353             echo "  /* Skip verify of ${function}, invalid_p == 0 */"
1354         elif [ "${invalid_p}" ]
1355         then
1356           echo "  if (${invalid_p})"
1357           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1358         elif [ "${predefault}" ]
1359         then
1360           echo "  if (gdbarch->${function} == ${predefault})"
1361           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1362         fi
1363         echo "  if (gdbarch_debug >= 2)"
1364         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1365         echo "  return gdbarch->${function};"
1366         echo "}"
1367         echo ""
1368         echo "void"
1369         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1370         echo "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})"
1371         echo "{"
1372         echo "  gdbarch->${function} = ${function};"
1373         echo "}"
1374     elif class_is_info_p
1375     then
1376         echo ""
1377         echo "${returntype}"
1378         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1379         echo "{"
1380         echo "  if (gdbarch_debug >= 2)"
1381         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1382         echo "  return gdbarch->${function};"
1383         echo "}"
1384     fi
1385 done
1386
1387 # All the trailing guff
1388 cat <<EOF
1389
1390
1391 /* Keep a registrary of per-architecture data-pointers required by GDB
1392    modules. */
1393
1394 struct gdbarch_data
1395 {
1396   int index;
1397 };
1398
1399 struct gdbarch_data_registration
1400 {
1401   gdbarch_data_ftype *init;
1402   struct gdbarch_data *data;
1403   struct gdbarch_data_registration *next;
1404 };
1405
1406 struct gdbarch_data_registrary
1407 {
1408   int nr;
1409   struct gdbarch_data_registration *registrations;
1410 };
1411
1412 struct gdbarch_data_registrary gdbarch_data_registrary =
1413 {
1414   0, NULL,
1415 };
1416
1417 struct gdbarch_data *
1418 register_gdbarch_data (gdbarch_data_ftype *init)
1419 {
1420   struct gdbarch_data_registration **curr;
1421   for (curr = &gdbarch_data_registrary.registrations;
1422        (*curr) != NULL;
1423        curr = &(*curr)->next);
1424   (*curr) = XMALLOC (struct gdbarch_data_registration);
1425   (*curr)->next = NULL;
1426   (*curr)->init = init;
1427   (*curr)->data = XMALLOC (struct gdbarch_data);
1428   (*curr)->data->index = gdbarch_data_registrary.nr++;
1429   return (*curr)->data;
1430 }
1431
1432
1433 /* Walk through all the registered users initializing each in turn. */
1434
1435 static void
1436 init_gdbarch_data (struct gdbarch *gdbarch)
1437 {
1438   struct gdbarch_data_registration *rego;
1439   gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1440   gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1441   for (rego = gdbarch_data_registrary.registrations;
1442        rego != NULL;
1443        rego = rego->next)
1444     {
1445       if (rego->data->index < gdbarch->nr_data)
1446         gdbarch->data[rego->data->index] = rego->init ();
1447     }
1448 }
1449
1450
1451 /* Return the current value of the specified per-architecture
1452    data-pointer. */
1453
1454 void *
1455 gdbarch_data (data)
1456      struct gdbarch_data *data;
1457 {
1458   if (data->index >= current_gdbarch->nr_data)
1459     internal_error ("gdbarch_data: request for non-existant data.");
1460   return current_gdbarch->data[data->index];
1461 }
1462
1463
1464
1465 /* Keep a registrary of swaped data required by GDB modules. */
1466
1467 struct gdbarch_swap
1468 {
1469   void *swap;
1470   struct gdbarch_swap_registration *source;
1471   struct gdbarch_swap *next;
1472 };
1473
1474 struct gdbarch_swap_registration
1475 {
1476   void *data;
1477   unsigned long sizeof_data;
1478   gdbarch_swap_ftype *init;
1479   struct gdbarch_swap_registration *next;
1480 };
1481
1482 struct gdbarch_swap_registrary
1483 {
1484   int nr;
1485   struct gdbarch_swap_registration *registrations;
1486 };
1487
1488 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1489 {
1490   0, NULL,
1491 };
1492
1493 void
1494 register_gdbarch_swap (void *data,
1495                        unsigned long sizeof_data,
1496                        gdbarch_swap_ftype *init)
1497 {
1498   struct gdbarch_swap_registration **rego;
1499   for (rego = &gdbarch_swap_registrary.registrations;
1500        (*rego) != NULL;
1501        rego = &(*rego)->next);
1502   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1503   (*rego)->next = NULL;
1504   (*rego)->init = init;
1505   (*rego)->data = data;
1506   (*rego)->sizeof_data = sizeof_data;
1507 }
1508
1509
1510 static void
1511 init_gdbarch_swap (struct gdbarch *gdbarch)
1512 {
1513   struct gdbarch_swap_registration *rego;
1514   struct gdbarch_swap **curr = &gdbarch->swap;
1515   for (rego = gdbarch_swap_registrary.registrations;
1516        rego != NULL;
1517        rego = rego->next)
1518     {
1519       if (rego->data != NULL)
1520         {
1521           (*curr) = XMALLOC (struct gdbarch_swap);
1522           (*curr)->source = rego;
1523           (*curr)->swap = xmalloc (rego->sizeof_data);
1524           (*curr)->next = NULL;
1525           memset (rego->data, 0, rego->sizeof_data);
1526           curr = &(*curr)->next;
1527         }
1528       if (rego->init != NULL)
1529         rego->init ();
1530     }
1531 }
1532
1533 static void
1534 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1535 {
1536   struct gdbarch_swap *curr;
1537   for (curr = gdbarch->swap;
1538        curr != NULL;
1539        curr = curr->next)
1540     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1541 }
1542
1543 static void
1544 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1545 {
1546   struct gdbarch_swap *curr;
1547   for (curr = gdbarch->swap;
1548        curr != NULL;
1549        curr = curr->next)
1550     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1551 }
1552
1553
1554 /* Keep a registrary of the architectures known by GDB. */
1555
1556 struct gdbarch_registration
1557 {
1558   enum bfd_architecture bfd_architecture;
1559   gdbarch_init_ftype *init;
1560   gdbarch_dump_tdep_ftype *dump_tdep;
1561   struct gdbarch_list *arches;
1562   struct gdbarch_registration *next;
1563 };
1564
1565 static struct gdbarch_registration *gdbarch_registrary = NULL;
1566
1567 static void
1568 append_name (const char ***buf, int *nr, const char *name)
1569 {
1570   *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1571   (*buf)[*nr] = name;
1572   *nr += 1;
1573 }
1574
1575 const char **
1576 gdbarch_printable_names (void)
1577 {
1578   if (GDB_MULTI_ARCH)
1579     {
1580       /* Accumulate a list of names based on the registed list of
1581          architectures. */
1582       enum bfd_architecture a;
1583       int nr_arches = 0;
1584       const char **arches = NULL;
1585       struct gdbarch_registration *rego;
1586       for (rego = gdbarch_registrary;
1587            rego != NULL;
1588            rego = rego->next)
1589         {
1590           const struct bfd_arch_info *ap;
1591           ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1592           if (ap == NULL)
1593             internal_error ("gdbarch_architecture_names: multi-arch unknown");
1594           do
1595             {
1596               append_name (&arches, &nr_arches, ap->printable_name);
1597               ap = ap->next;
1598             }
1599           while (ap != NULL);
1600         }
1601       append_name (&arches, &nr_arches, NULL);
1602       return arches;
1603     }
1604   else
1605     /* Just return all the architectures that BFD knows.  Assume that
1606        the legacy architecture framework supports them. */
1607     return bfd_arch_list ();
1608 }
1609
1610
1611 void
1612 gdbarch_register (enum bfd_architecture bfd_architecture,
1613                   gdbarch_init_ftype *init,
1614                   gdbarch_dump_tdep_ftype *dump_tdep)
1615 {
1616   struct gdbarch_registration **curr;
1617   const struct bfd_arch_info *bfd_arch_info;
1618   /* Check that BFD reconizes this architecture */
1619   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1620   if (bfd_arch_info == NULL)
1621     {
1622       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1623     }
1624   /* Check that we haven't seen this architecture before */
1625   for (curr = &gdbarch_registrary;
1626        (*curr) != NULL;
1627        curr = &(*curr)->next)
1628     {
1629       if (bfd_architecture == (*curr)->bfd_architecture)
1630         internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1631                bfd_arch_info->printable_name);
1632     }
1633   /* log it */
1634   if (gdbarch_debug)
1635     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1636                         bfd_arch_info->printable_name,
1637                         (long) init);
1638   /* Append it */
1639   (*curr) = XMALLOC (struct gdbarch_registration);
1640   (*curr)->bfd_architecture = bfd_architecture;
1641   (*curr)->init = init;
1642   (*curr)->dump_tdep = dump_tdep;
1643   (*curr)->arches = NULL;
1644   (*curr)->next = NULL;
1645   /* When non- multi-arch, install what ever target dump routine we've
1646      been provided - hopefully that routine has been writen correct
1647      and works regardless of multi-arch. */
1648   if (!GDB_MULTI_ARCH && dump_tdep != NULL
1649       && startup_gdbarch.dump_tdep == NULL)
1650     startup_gdbarch.dump_tdep = dump_tdep;
1651 }
1652
1653 void
1654 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1655                        gdbarch_init_ftype *init)
1656 {
1657   gdbarch_register (bfd_architecture, init, NULL);
1658 }
1659
1660
1661 /* Look for an architecture using gdbarch_info.  Base search on only
1662    BFD_ARCH_INFO and BYTE_ORDER. */
1663
1664 struct gdbarch_list *
1665 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1666                              const struct gdbarch_info *info)
1667 {
1668   for (; arches != NULL; arches = arches->next)
1669     {
1670       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1671         continue;
1672       if (info->byte_order != arches->gdbarch->byte_order)
1673         continue;
1674       return arches;
1675     }
1676   return NULL;
1677 }
1678
1679
1680 /* Update the current architecture. Return ZERO if the update request
1681    failed. */
1682
1683 int
1684 gdbarch_update (struct gdbarch_info info)
1685 {
1686   struct gdbarch *new_gdbarch;
1687   struct gdbarch_list **list;
1688   struct gdbarch_registration *rego;
1689
1690   /* Fill in any missing bits. Most important is the bfd_architecture
1691      which is used to select the target architecture. */
1692   if (info.bfd_architecture == bfd_arch_unknown)
1693     {
1694       if (info.bfd_arch_info != NULL)
1695         info.bfd_architecture = info.bfd_arch_info->arch;
1696       else if (info.abfd != NULL)
1697         info.bfd_architecture = bfd_get_arch (info.abfd);
1698       /* FIXME - should query BFD for its default architecture. */
1699       else
1700         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1701     }
1702   if (info.bfd_arch_info == NULL)
1703     {
1704       if (target_architecture_auto && info.abfd != NULL)
1705         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1706       else
1707         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1708     }
1709   if (info.byte_order == 0)
1710     {
1711       if (target_byte_order_auto && info.abfd != NULL)
1712         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1713                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1714                            : 0);
1715       else
1716         info.byte_order = current_gdbarch->byte_order;
1717       /* FIXME - should query BFD for its default byte-order. */
1718     }
1719   /* A default for abfd? */
1720
1721   /* Find the target that knows about this architecture. */
1722   for (rego = gdbarch_registrary;
1723        rego != NULL;
1724        rego = rego->next)
1725     if (rego->bfd_architecture == info.bfd_architecture)
1726       break;
1727   if (rego == NULL)
1728     {
1729       if (gdbarch_debug)
1730         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1731       return 0;
1732     }
1733
1734   if (gdbarch_debug)
1735     {
1736       fprintf_unfiltered (gdb_stdlog,
1737                           "gdbarch_update: info.bfd_architecture %d (%s)\n",
1738                           info.bfd_architecture,
1739                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1740       fprintf_unfiltered (gdb_stdlog,
1741                           "gdbarch_update: info.bfd_arch_info %s\n",
1742                           (info.bfd_arch_info != NULL
1743                            ? info.bfd_arch_info->printable_name
1744                            : "(null)"));
1745       fprintf_unfiltered (gdb_stdlog,
1746                           "gdbarch_update: info.byte_order %d (%s)\n",
1747                           info.byte_order,
1748                           (info.byte_order == BIG_ENDIAN ? "big"
1749                            : info.byte_order == LITTLE_ENDIAN ? "little"
1750                            : "default"));
1751       fprintf_unfiltered (gdb_stdlog,
1752                           "gdbarch_update: info.abfd 0x%lx\n",
1753                           (long) info.abfd);
1754       fprintf_unfiltered (gdb_stdlog,
1755                           "gdbarch_update: info.tdep_info 0x%lx\n",
1756                           (long) info.tdep_info);
1757     }
1758
1759   /* Ask the target for a replacement architecture. */
1760   new_gdbarch = rego->init (info, rego->arches);
1761
1762   /* Did the target like it?  No. Reject the change. */
1763   if (new_gdbarch == NULL)
1764     {
1765       if (gdbarch_debug)
1766         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1767       return 0;
1768     }
1769
1770   /* Did the architecture change?  No. Do nothing. */
1771   if (current_gdbarch == new_gdbarch)
1772     {
1773       if (gdbarch_debug)
1774         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1775                             (long) new_gdbarch,
1776                             new_gdbarch->bfd_arch_info->printable_name);
1777       return 1;
1778     }
1779
1780   /* Swap all data belonging to the old target out */
1781   swapout_gdbarch_swap (current_gdbarch);
1782
1783   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
1784   for (list = &rego->arches;
1785        (*list) != NULL;
1786        list = &(*list)->next)
1787     {
1788       if ((*list)->gdbarch == new_gdbarch)
1789         {
1790           if (gdbarch_debug)
1791             fprintf_unfiltered (gdb_stdlog,
1792                                 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1793                                 (long) new_gdbarch,
1794                                 new_gdbarch->bfd_arch_info->printable_name);
1795           current_gdbarch = new_gdbarch;
1796           swapin_gdbarch_swap (new_gdbarch);
1797           return 1;
1798         }
1799     }
1800
1801   /* Append this new architecture to this targets list. */
1802   (*list) = XMALLOC (struct gdbarch_list);
1803   (*list)->next = NULL;
1804   (*list)->gdbarch = new_gdbarch;
1805
1806   /* Switch to this new architecture.  Dump it out. */
1807   current_gdbarch = new_gdbarch;
1808   if (gdbarch_debug)
1809     {
1810       fprintf_unfiltered (gdb_stdlog,
1811                           "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1812                           (long) new_gdbarch,
1813                           new_gdbarch->bfd_arch_info->printable_name);
1814     }
1815
1816   /* Check that the newly installed architecture is valid.  Plug in
1817      any post init values.  */
1818   new_gdbarch->dump_tdep = rego->dump_tdep;
1819   verify_gdbarch (new_gdbarch);
1820
1821   /* Initialize the per-architecture memory (swap) areas.
1822      CURRENT_GDBARCH must be update before these modules are
1823      called. */
1824   init_gdbarch_swap (new_gdbarch);
1825
1826   /* Initialize the per-architecture data-pointer of all parties that
1827      registered an interest in this architecture.  CURRENT_GDBARCH
1828      must be updated before these modules are called. */
1829   init_gdbarch_data (new_gdbarch);
1830
1831   if (gdbarch_debug)
1832     gdbarch_dump (current_gdbarch, gdb_stdlog);
1833
1834   return 1;
1835 }
1836
1837
1838 /* Disassembler */
1839
1840 /* Pointer to the target-dependent disassembly function.  */
1841 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1842 disassemble_info tm_print_insn_info;
1843
1844
1845 extern void _initialize_gdbarch (void);
1846
1847 void
1848 _initialize_gdbarch ()
1849 {
1850   struct cmd_list_element *c;
1851
1852   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1853   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1854   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1855   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1856   tm_print_insn_info.print_address_func = dis_asm_print_address;
1857
1858   add_show_from_set (add_set_cmd ("arch",
1859                                   class_maintenance,
1860                                   var_zinteger,
1861                                   (char *)&gdbarch_debug,
1862                                   "Set architecture debugging.\n\\
1863 When non-zero, architecture debugging is enabled.", &setdebuglist),
1864                      &showdebuglist);
1865   c = add_set_cmd ("archdebug",
1866                    class_maintenance,
1867                    var_zinteger,
1868                    (char *)&gdbarch_debug,
1869                    "Set architecture debugging.\n\\
1870 When non-zero, architecture debugging is enabled.", &setlist);
1871
1872   deprecate_cmd (c, "set debug arch");
1873   deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
1874 }
1875 EOF
1876
1877 # close things off
1878 exec 1>&2
1879 #../move-if-change new-gdbarch.c gdbarch.c
1880 compare_new gdbarch.c