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