gdb/gdbarch.sh

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