gdb/gdbarch.sh

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