gdb/gdbarch.sh

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