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 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
 568
 569
 570
 571 /* The target-system-dependant byte order is dynamic */
 572
 573 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 574    is selectable at runtime.  The user can use the \`\`set endian''
 575    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 576    target_byte_order should be auto-detected (from the program image
 577    say). */
 578
 579 #if GDB_MULTI_ARCH
 580 /* Multi-arch GDB is always bi-endian. */
 581 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 582 #endif
 583
 584 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 585 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 586    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 587 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 588 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 589 #else
 590 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 591 #endif
 592 #endif
 593
 594 extern int target_byte_order;
 595 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 596 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 597    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 598 #undef TARGET_BYTE_ORDER
 599 #endif
 600 #ifndef TARGET_BYTE_ORDER
 601 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 602 #endif
 603
 604 extern int target_byte_order_auto;
 605 #ifndef TARGET_BYTE_ORDER_AUTO
 606 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 607 #endif
 608
 609
 610
 611 /* The target-system-dependant BFD architecture is dynamic */
 612
 613 extern int target_architecture_auto;
 614 #ifndef TARGET_ARCHITECTURE_AUTO
 615 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 616 #endif
 617
 618 extern const struct bfd_arch_info *target_architecture;
 619 #ifndef TARGET_ARCHITECTURE
 620 #define TARGET_ARCHITECTURE (target_architecture + 0)
 621 #endif
 622
 623 /* Notify the target dependant backend of a change to the selected
 624    architecture. A zero return status indicates that the target did
 625    not like the change. */
 626
 627 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
 628
 629
 630
 631 /* The target-system-dependant disassembler is semi-dynamic */
 632
 633 #include "dis-asm.h"            /* Get defs for disassemble_info */
 634
 635 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
 636                                 int len, disassemble_info *info);
 637
 638 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
 639                                   disassemble_info *info);
 640
 641 extern void dis_asm_print_address (bfd_vma addr,
 642                                    disassemble_info *info);
 643
 644 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
 645 extern disassemble_info tm_print_insn_info;
 646 #ifndef TARGET_PRINT_INSN
 647 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
 648 #endif
 649 #ifndef TARGET_PRINT_INSN_INFO
 650 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
 651 #endif
 652
 653
 654
 655 /* Explicit test for D10V architecture.
 656    USE of these macro's is *STRONGLY* discouraged. */
 657
 658 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
 659 #ifndef D10V_MAKE_DADDR
 660 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
 661 #endif
 662 #ifndef D10V_MAKE_IADDR
 663 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
 664 #endif
 665
 666
 667 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
 668 #ifndef FRAMELESS_FUNCTION_INVOCATION
 669 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
 670 #endif
 671
 672
 673 /* Fallback definition of REGISTER_CONVERTIBLE etc */
 674 extern int generic_register_convertible_not (int reg_nr);
 675 #ifndef REGISTER_CONVERTIBLE
 676 #define REGISTER_CONVERTIBLE(x) (0)
 677 #endif
 678 #ifndef REGISTER_CONVERT_TO_VIRTUAL
 679 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
 680 #endif
 681 #ifndef REGISTER_CONVERT_TO_RAW
 682 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
 683 #endif
 684
 685
 686 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
 687 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
 688 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
 689 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
 690 #else
 691 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
 692 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
 693 #endif
 694 #endif
 695
 696
 697 /* Fallback definition for REGISTER_NAME for systems still defining
 698    REGISTER_NAMES. */
 699 #ifndef REGISTER_NAME
 700 extern char *gdb_register_names[];
 701 #define REGISTER_NAME(i) gdb_register_names[i]
 702 #endif
 703
 704
 705 /* Set the dynamic target-system-dependant parameters (architecture,
 706    byte-order, ...) using information found in the BFD */
 707
 708 extern void set_gdbarch_from_file (bfd *);
 709
 710
 711 /* Explicitly set the dynamic target-system-dependant parameters based
 712    on bfd_architecture and machine. */
 713
 714 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
 715
 716
 717 /* Initialize the current architecture to the "first" one we find on
 718    our list.  */
 719
 720 extern void initialize_current_architecture (void);
 721
 722 /* Helper function for targets that don't know how my arguments are
 723    being passed */
 724
 725 extern int frame_num_args_unknown (struct frame_info *fi);
 726
 727
 728 /* gdbarch trace variable */
 729 extern int gdbarch_debug;
 730
 731 extern void gdbarch_dump (void);
 732
 733 #endif
 734 EOF
 735 exec 1>&2
 736 #../move-if-change new-gdbarch.h gdbarch.h
 737 if ! test -r gdbarch.h
 738 then
 739   echo "gdbarch.h missing? cp new-gdbarch.h gdbarch.h" 1>&2
 740 elif diff -c gdbarch.h new-gdbarch.h
 741 then
 742   echo "gdbarch.h unchanged" 1>&2
 743 else
 744   echo "gdbarch.h has changed? cp new-gdbarch.h gdbarch.h" 1>&2
 745 fi
 746
 747
 748 #
 749 # C file
 750 #
 751
 752 exec > new-gdbarch.c
 753 copyright
 754 cat <<EOF
 755
 756 #include "defs.h"
 757
 758 #if GDB_MULTI_ARCH
 759 #include "gdbcmd.h"
 760 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
 761 #else
 762 /* Just include everything in sight so that the every old definition
 763    of macro is visible. */
 764 #include "gdb_string.h"
 765 #include <ctype.h>
 766 #include "symtab.h"
 767 #include "frame.h"
 768 #include "inferior.h"
 769 #include "breakpoint.h"
 770 #include "wait.h"
 771 #include "gdbcore.h"
 772 #include "gdbcmd.h"
 773 #include "target.h"
 774 #include "gdbthread.h"
 775 #include "annotate.h"
 776 #include "symfile.h"            /* for overlay functions */
 777 #endif
 778 #include "symcat.h"
 779
 780
 781 /* Static function declarations */
 782
 783 static void verify_gdbarch (struct gdbarch *gdbarch);
 784 static void init_gdbarch_data (struct gdbarch *);
 785 static void init_gdbarch_swap (struct gdbarch *);
 786 static void swapout_gdbarch_swap (struct gdbarch *);
 787 static void swapin_gdbarch_swap (struct gdbarch *);
 788
 789 /* Convenience macro for allocting typesafe memory. */
 790
 791 #ifndef XMALLOC
 792 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
 793 #endif
 794
 795
 796 /* Non-zero if we want to trace architecture code.  */
 797
 798 #ifndef GDBARCH_DEBUG
 799 #define GDBARCH_DEBUG 0
 800 #endif
 801 int gdbarch_debug = GDBARCH_DEBUG;
 802
 803 EOF
 804
 805 # gdbarch open the gdbarch object
 806 echo ""
 807 echo "/* Maintain the struct gdbarch object */"
 808 echo ""
 809 echo "struct gdbarch"
 810 echo "{"
 811 echo "  /* basic architectural information */"
 812 function_list | while eval read $read
 813 do
 814   case "${class}" in
 815     "i" ) echo "  ${returntype} ${function};" ;;
 816   esac
 817 done
 818 echo ""
 819 echo "  /* target specific vector. */"
 820 echo "  struct gdbarch_tdep *tdep;"
 821 echo ""
 822 echo "  /* per-architecture data-pointers */"
 823 echo "  int nr_data;"
 824 echo "  void **data;"
 825 echo ""
 826 echo "  /* per-architecture swap-regions */"
 827 echo "  struct gdbarch_swap *swap;"
 828 echo ""
 829 cat <<EOF
 830   /* Multi-arch values.
 831
 832      When extending this structure you must:
 833
 834      Add the field below.
 835
 836      Declare set/get functions and define the corresponding
 837      macro in gdbarch.h.
 838
 839      gdbarch_alloc(): If zero/NULL is not a suitable default,
 840      initialize the new field.
 841
 842      verify_gdbarch(): Confirm that the target updated the field
 843      correctly.
 844
 845      gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
 846      field is dumped out
 847
 848      \`\`default_gdbarch()'': Append an initial value to the static
 849      variable (base values on the host's c-type system).
 850
 851      get_gdbarch(): Implement the set/get functions (probably using
 852      the macro's as shortcuts).
 853
 854      */
 855
 856 EOF
 857 function_list | while eval read $read
 858 do
 859   case "${class}" in
 860     "v" ) echo "  ${returntype} ${function};" ;;
 861     "f" ) echo "  gdbarch_${function}_ftype *${function}${attrib};" ;;
 862   esac
 863 done
 864 echo "};"
 865
 866 # A pre-initialized vector
 867 echo ""
 868 echo ""
 869 cat <<EOF
 870 /* The default architecture uses host values (for want of a better
 871    choice). */
 872 EOF
 873 echo ""
 874 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
 875 echo ""
 876 echo "struct gdbarch default_gdbarch = {"
 877 echo "  /* basic architecture information */"
 878 function_list | while eval read $read
 879 do
 880   case "${class}" in
 881     "i" ) echo "  ${default}," ;;
 882   esac
 883 done
 884 cat <<EOF
 885   /* target specific vector */
 886   NULL,
 887   /*per-architecture data-pointers and swap regions */
 888   0, NULL, NULL,
 889   /* Multi-arch values */
 890 EOF
 891 function_list | while eval read $read
 892 do
 893   case "${class}" in
 894     "f" | "v" ) echo "  ${default}," ;;
 895   esac
 896 done
 897 cat <<EOF
 898   /* default_gdbarch() */
 899 };
 900 struct gdbarch *current_gdbarch = &default_gdbarch;
 901 EOF
 902
 903 # Create a new gdbarch struct
 904 echo ""
 905 echo ""
 906 cat <<EOF
 907 /* Create a new \`\`struct gdbarch'' based in information provided by
 908    \`\`struct gdbarch_info''. */
 909 EOF
 910 echo ""
 911 cat <<EOF
 912 struct gdbarch *
 913 gdbarch_alloc (const struct gdbarch_info *info,
 914                struct gdbarch_tdep *tdep)
 915 {
 916   struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
 917   memset (gdbarch, 0, sizeof (*gdbarch));
 918
 919   gdbarch->tdep = tdep;
 920 EOF
 921 echo ""
 922 function_list | while eval read $read
 923 do
 924   case "${class}" in
 925     "i" ) echo "  gdbarch->${function} = info->${function};"
 926   esac
 927 done
 928 echo ""
 929 echo "  /* Force the explicit initialization of these. */"
 930 function_list | while eval read $read
 931 do
 932   case "${class}" in
 933     "f" | "v" )
 934         if [ "${init}" != "" -a "${init}" != "0" ]
 935         then
 936           echo "  gdbarch->${function} = ${init};"
 937         fi
 938         ;;
 939   esac
 940 done
 941 cat <<EOF
 942   /* gdbarch_alloc() */
 943
 944   return gdbarch;
 945 }
 946 EOF
 947
 948 # verify a new architecture
 949 echo ""
 950 echo ""
 951 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
 952 echo ""
 953 cat <<EOF
 954 static void
 955 verify_gdbarch (struct gdbarch *gdbarch)
 956 {
 957   /* Only perform sanity checks on a multi-arch target. */
 958   if (GDB_MULTI_ARCH <= 0)
 959     return;
 960   /* fundamental */
 961   if (gdbarch->byte_order == 0)
 962     internal_error ("verify_gdbarch: byte-order unset");
 963   if (gdbarch->bfd_arch_info == NULL)
 964     internal_error ("verify_gdbarch: bfd_arch_info unset");
 965   /* Check those that need to be defined for the given multi-arch level. */
 966 EOF
 967 function_list | while eval read $read
 968 do
 969   case "${class}" in
 970     "f" | "v" )
 971         if [ "${init_p}" ]
 972         then
 973           echo "  if ((GDB_MULTI_ARCH >= ${level})"
 974           echo "      && (${init_p}))"
 975           echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
 976         elif [ "${init}" ]
 977         then
 978           echo "  if ((GDB_MULTI_ARCH >= ${level})"
 979           echo "      && (gdbarch->${function} == ${init}))"
 980           echo "    internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
 981         fi
 982         ;;
 983   esac
 984 done
 985 cat <<EOF
 986 }
 987 EOF
 988
 989 # dump the structure
 990 echo ""
 991 echo ""
 992 echo "/* Print out the details of the current architecture. */"
 993 echo ""
 994 cat <<EOF
 995 void
 996 gdbarch_dump (void)
 997 {
 998 EOF
 999 function_list | while eval read $read
1000 do
1001   case "${class}" in
1002     "f" )
1003         echo "  fprintf_unfiltered (gdb_stdlog,"
1004         echo "                      \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1005         echo "                      (long) current_gdbarch->${function}"
1006         echo "                      /*${macro} ()*/);"
1007         ;;
1008     * )
1009         test "${fmt}" || fmt="%ld"
1010         test "${print}" || print="(long) ${macro}"
1011         if [ "${print_p}" = "#" ]
1012         then
1013           echo "#ifdef ${macro}"
1014           echo "  fprintf_unfiltered (gdb_stdlog,"
1015           echo "                      \"gdbarch_update: ${macro} = ${fmt}\\n\","
1016           echo "                      ${print});"
1017           echo "#endif"
1018         elif [ "${print_p}" ]
1019         then
1020           echo "  if (${print_p})"
1021           echo "    fprintf_unfiltered (gdb_stdlog,"
1022           echo "                        \"gdbarch_update: ${macro} = ${fmt}\\n\","
1023           echo "                        ${print});"
1024         else
1025           echo "  fprintf_unfiltered (gdb_stdlog,"
1026           echo "                      \"gdbarch_update: ${macro} = ${fmt}\\n\","
1027           echo "                      ${print});"
1028         fi
1029         ;;
1030   esac
1031 done
1032 echo "}"
1033
1034
1035 # GET/SET
1036 echo ""
1037 cat <<EOF
1038 struct gdbarch_tdep *
1039 gdbarch_tdep (struct gdbarch *gdbarch)
1040 {
1041   if (gdbarch_debug >= 2)
1042     /* FIXME: gdb_std??? */
1043     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1044   return gdbarch->tdep;
1045 }
1046 EOF
1047 echo ""
1048 function_list | while eval read $read
1049 do
1050   case "${class}" in
1051     "f" )
1052         echo ""
1053         echo "${returntype}"
1054         if [ "${formal}" = "void" ]
1055         then
1056           echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1057         else
1058           echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1059         fi
1060         echo "{"
1061         echo "  if (gdbarch->${function} == 0)"
1062         echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1063         echo "  if (gdbarch_debug >= 2)"
1064         echo "    /* FIXME: gdb_std??? */"
1065         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1066         test "${actual}" = "-" && actual=""
1067         if [ "${returntype}" = "void" ]
1068         then
1069           echo "  gdbarch->${function} (${actual});"
1070         else
1071           echo "  return gdbarch->${function} (${actual});"
1072         fi
1073         echo "}"
1074         echo ""
1075         echo "void"
1076         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1077         echo "            `echo ${function} | sed -e 's/./ /g'`  gdbarch_${function}_ftype ${function})"
1078         echo "{"
1079         echo "  gdbarch->${function} = ${function};"
1080         echo "}"
1081         ;;
1082     "v" )
1083         echo ""
1084         echo "${returntype}"
1085         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1086         echo "{"
1087         if [ "${init_p}" ]
1088         then
1089           echo "  if (${init_p})"
1090           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1091         elif [ "${init}" ]
1092         then
1093           echo "  if (gdbarch->${function} == ${init})"
1094           echo "    internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1095         fi
1096         echo "  if (gdbarch_debug >= 2)"
1097         echo "    /* FIXME: gdb_std??? */"
1098         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1099         echo "  return gdbarch->${function};"
1100         echo "}"
1101         echo ""
1102         echo "void"
1103         echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1104         echo "            `echo ${function} | sed -e 's/./ /g'`  ${returntype} ${function})"
1105         echo "{"
1106         echo "  gdbarch->${function} = ${function};"
1107         echo "}"
1108         ;;
1109     "i" )
1110         echo ""
1111         echo "${returntype}"
1112         echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1113         echo "{"
1114         echo "  if (gdbarch_debug >= 2)"
1115         echo "    /* FIXME: gdb_std??? */"
1116         echo "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1117         echo "  return gdbarch->${function};"
1118         echo "}"
1119         ;;
1120   esac
1121 done
1122
1123 # All the trailing guff
1124 cat <<EOF
1125
1126
1127 /* Keep a registrary of per-architecture data-pointers required by GDB
1128    modules. */
1129
1130 struct gdbarch_data
1131 {
1132   int index;
1133 };
1134
1135 struct gdbarch_data_registration
1136 {
1137   gdbarch_data_ftype *init;
1138   struct gdbarch_data *data;
1139   struct gdbarch_data_registration *next;
1140 };
1141
1142 struct gdbarch_data_registrary
1143 {
1144   int nr;
1145   struct gdbarch_data_registration *registrations;
1146 };
1147
1148 struct gdbarch_data_registrary gdbarch_data_registrary =
1149 {
1150   0, NULL,
1151 };
1152
1153 struct gdbarch_data *
1154 register_gdbarch_data (gdbarch_data_ftype *init)
1155 {
1156   struct gdbarch_data_registration **curr;
1157   for (curr = &gdbarch_data_registrary.registrations;
1158        (*curr) != NULL;
1159        curr = &(*curr)->next);
1160   (*curr) = XMALLOC (struct gdbarch_data_registration);
1161   (*curr)->next = NULL;
1162   (*curr)->init = init;
1163   (*curr)->data = XMALLOC (struct gdbarch_data);
1164   (*curr)->data->index = gdbarch_data_registrary.nr++;
1165   return (*curr)->data;
1166 }
1167
1168
1169 /* Walk through all the registered users initializing each in turn. */
1170
1171 static void
1172 init_gdbarch_data (struct gdbarch *gdbarch)
1173 {
1174   struct gdbarch_data_registration *rego;
1175   gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1176   gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1177   for (rego = gdbarch_data_registrary.registrations;
1178        rego != NULL;
1179        rego = rego->next)
1180     {
1181       if (rego->data->index < gdbarch->nr_data)
1182         gdbarch->data[rego->data->index] = rego->init ();
1183     }
1184 }
1185
1186
1187 /* Return the current value of the specified per-architecture
1188    data-pointer. */
1189
1190 void *
1191 gdbarch_data (data)
1192      struct gdbarch_data *data;
1193 {
1194   if (data->index >= current_gdbarch->nr_data)
1195     internal_error ("gdbarch_data: request for non-existant data.");
1196   return current_gdbarch->data[data->index];
1197 }
1198
1199
1200
1201 /* Keep a registrary of swaped data required by GDB modules. */
1202
1203 struct gdbarch_swap
1204 {
1205   void *swap;
1206   struct gdbarch_swap_registration *source;
1207   struct gdbarch_swap *next;
1208 };
1209
1210 struct gdbarch_swap_registration
1211 {
1212   void *data;
1213   unsigned long sizeof_data;
1214   gdbarch_swap_ftype *init;
1215   struct gdbarch_swap_registration *next;
1216 };
1217
1218 struct gdbarch_swap_registrary
1219 {
1220   int nr;
1221   struct gdbarch_swap_registration *registrations;
1222 };
1223
1224 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1225 {
1226   0, NULL,
1227 };
1228
1229 void
1230 register_gdbarch_swap (void *data,
1231                        unsigned long sizeof_data,
1232                        gdbarch_swap_ftype *init)
1233 {
1234   struct gdbarch_swap_registration **rego;
1235   for (rego = &gdbarch_swap_registrary.registrations;
1236        (*rego) != NULL;
1237        rego = &(*rego)->next);
1238   (*rego) = XMALLOC (struct gdbarch_swap_registration);
1239   (*rego)->next = NULL;
1240   (*rego)->init = init;
1241   (*rego)->data = data;
1242   (*rego)->sizeof_data = sizeof_data;
1243 }
1244
1245
1246 static void
1247 init_gdbarch_swap (struct gdbarch *gdbarch)
1248 {
1249   struct gdbarch_swap_registration *rego;
1250   struct gdbarch_swap **curr = &gdbarch->swap;
1251   for (rego = gdbarch_swap_registrary.registrations;
1252        rego != NULL;
1253        rego = rego->next)
1254     {
1255       if (rego->data != NULL)
1256         {
1257           (*curr) = XMALLOC (struct gdbarch_swap);
1258           (*curr)->source = rego;
1259           (*curr)->swap = xmalloc (rego->sizeof_data);
1260           (*curr)->next = NULL;
1261           memset (rego->data, 0, rego->sizeof_data);
1262           curr = &(*curr)->next;
1263         }
1264       if (rego->init != NULL)
1265         rego->init ();
1266     }
1267 }
1268
1269 static void
1270 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1271 {
1272   struct gdbarch_swap *curr;
1273   for (curr = gdbarch->swap;
1274        curr != NULL;
1275        curr = curr->next)
1276     memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1277 }
1278
1279 static void
1280 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1281 {
1282   struct gdbarch_swap *curr;
1283   for (curr = gdbarch->swap;
1284        curr != NULL;
1285        curr = curr->next)
1286     memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1287 }
1288
1289
1290 /* Keep a registrary of the architectures known by GDB. */
1291
1292 struct gdbarch_init_registration
1293 {
1294   enum bfd_architecture bfd_architecture;
1295   gdbarch_init_ftype *init;
1296   struct gdbarch_list *arches;
1297   struct gdbarch_init_registration *next;
1298 };
1299
1300 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1301
1302 void
1303 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1304                        gdbarch_init_ftype *init)
1305 {
1306   struct gdbarch_init_registration **curr;
1307   const struct bfd_arch_info *bfd_arch_info;
1308   /* Check that BFD reconizes this architecture */
1309   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1310   if (bfd_arch_info == NULL)
1311     {
1312       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1313     }
1314   /* Check that we haven't seen this architecture before */
1315   for (curr = &gdbarch_init_registrary;
1316        (*curr) != NULL;
1317        curr = &(*curr)->next)
1318     {
1319       if (bfd_architecture == (*curr)->bfd_architecture)
1320         internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1321                bfd_arch_info->printable_name);
1322     }
1323   /* log it */
1324   if (gdbarch_debug)
1325     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1326                         bfd_arch_info->printable_name,
1327                         (long) init);
1328   /* Append it */
1329   (*curr) = XMALLOC (struct gdbarch_init_registration);
1330   (*curr)->bfd_architecture = bfd_architecture;
1331   (*curr)->init = init;
1332   (*curr)->arches = NULL;
1333   (*curr)->next = NULL;
1334 }
1335
1336
1337
1338 /* Look for an architecture using gdbarch_info.  Base search on only
1339    BFD_ARCH_INFO and BYTE_ORDER. */
1340
1341 struct gdbarch_list *
1342 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1343                              const struct gdbarch_info *info)
1344 {
1345   for (; arches != NULL; arches = arches->next)
1346     {
1347       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1348         continue;
1349       if (info->byte_order != arches->gdbarch->byte_order)
1350         continue;
1351       return arches;
1352     }
1353   return NULL;
1354 }
1355
1356
1357 /* Update the current architecture. Return ZERO if the update request
1358    failed. */
1359
1360 int
1361 gdbarch_update (struct gdbarch_info info)
1362 {
1363   struct gdbarch *new_gdbarch;
1364   struct gdbarch_list **list;
1365   struct gdbarch_init_registration *rego;
1366
1367   /* Fill in any missing bits. Most important is the bfd_architecture
1368      which is used to select the target architecture. */
1369   if (info.bfd_architecture == bfd_arch_unknown)
1370     {
1371       if (info.bfd_arch_info != NULL)
1372         info.bfd_architecture = info.bfd_arch_info->arch;
1373       else if (info.abfd != NULL)
1374         info.bfd_architecture = bfd_get_arch (info.abfd);
1375       /* FIXME - should query BFD for its default architecture. */
1376       else
1377         info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1378     }
1379   if (info.bfd_arch_info == NULL)
1380     {
1381       if (target_architecture_auto && info.abfd != NULL)
1382         info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1383       else
1384         info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1385     }
1386   if (info.byte_order == 0)
1387     {
1388       if (target_byte_order_auto && info.abfd != NULL)
1389         info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1390                            : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1391                            : 0);
1392       else
1393         info.byte_order = current_gdbarch->byte_order;
1394       /* FIXME - should query BFD for its default byte-order. */
1395     }
1396   /* A default for abfd? */
1397
1398   /* Find the target that knows about this architecture. */
1399   for (rego = gdbarch_init_registrary;
1400        rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1401        rego = rego->next);
1402   if (rego == NULL)
1403     {
1404       if (gdbarch_debug)
1405         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1406       return 0;
1407     }
1408
1409   if (gdbarch_debug)
1410     {
1411       fprintf_unfiltered (gdb_stdlog,
1412                           "gdbarch_update: info.bfd_architecture %d (%s)\n",
1413                           info.bfd_architecture,
1414                           bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1415       fprintf_unfiltered (gdb_stdlog,
1416                           "gdbarch_update: info.bfd_arch_info %s\n",
1417                           (info.bfd_arch_info != NULL
1418                            ? info.bfd_arch_info->printable_name
1419                            : "(null)"));
1420       fprintf_unfiltered (gdb_stdlog,
1421                           "gdbarch_update: info.byte_order %d (%s)\n",
1422                           info.byte_order,
1423                           (info.byte_order == BIG_ENDIAN ? "big"
1424                            : info.byte_order == LITTLE_ENDIAN ? "little"
1425                            : "default"));
1426       fprintf_unfiltered (gdb_stdlog,
1427                           "gdbarch_update: info.abfd 0x%lx\n",
1428                           (long) info.abfd);
1429       fprintf_unfiltered (gdb_stdlog,
1430                           "gdbarch_update: info.tdep_info 0x%lx\n",
1431                           (long) info.tdep_info);
1432     }
1433
1434   /* Ask the target for a replacement architecture. */
1435   new_gdbarch = rego->init (info, rego->arches);
1436
1437   /* Did the target like it?  No. Reject the change. */
1438   if (new_gdbarch == NULL)
1439     {
1440       if (gdbarch_debug)
1441         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1442       return 0;
1443     }
1444
1445   /* Did the architecture change?  No. Do nothing. */
1446   if (current_gdbarch == new_gdbarch)
1447     {
1448       if (gdbarch_debug)
1449         fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1450                             (long) new_gdbarch,
1451                             new_gdbarch->bfd_arch_info->printable_name);
1452       return 1;
1453     }
1454
1455   /* Swap all data belonging to the old target out */
1456   swapout_gdbarch_swap (current_gdbarch);
1457
1458   /* Is this a pre-existing architecture?  Yes. Swap it in.  */
1459   for (list = &rego->arches;
1460        (*list) != NULL;
1461        list = &(*list)->next)
1462     {
1463       if ((*list)->gdbarch == new_gdbarch)
1464         {
1465           if (gdbarch_debug)
1466             fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1467                                 (long) new_gdbarch,
1468                                 new_gdbarch->bfd_arch_info->printable_name);
1469           current_gdbarch = new_gdbarch;
1470           swapin_gdbarch_swap (new_gdbarch);
1471           return 1;
1472         }
1473     }
1474
1475   /* Append this new architecture to this targets list. */
1476   (*list) = XMALLOC (struct gdbarch_list);
1477   (*list)->next = NULL;
1478   (*list)->gdbarch = new_gdbarch;
1479
1480   /* Switch to this new architecture.  Dump it out. */
1481   current_gdbarch = new_gdbarch;
1482   if (gdbarch_debug)
1483     {
1484       fprintf_unfiltered (gdb_stdlog,
1485                           "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1486                           (long) new_gdbarch,
1487                           new_gdbarch->bfd_arch_info->printable_name);
1488       gdbarch_dump ();
1489     }
1490
1491   /* Check that the newly installed architecture is valid.  */
1492   verify_gdbarch (new_gdbarch);
1493
1494   /* Initialize the per-architecture memory (swap) areas.
1495      CURRENT_GDBARCH must be update before these modules are
1496      called. */
1497   init_gdbarch_swap (new_gdbarch);
1498
1499   /* Initialize the per-architecture data-pointer of all parties that
1500      registered an interest in this architecture.  CURRENT_GDBARCH
1501      must be updated before these modules are called. */
1502   init_gdbarch_data (new_gdbarch);
1503
1504   return 1;
1505 }
1506
1507
1508
1509 /* Functions to manipulate the endianness of the target.  */
1510
1511 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1512 /* compat - Catch old targets that expect a selectable byte-order to
1513    default to BIG_ENDIAN */
1514 #ifndef TARGET_BYTE_ORDER_DEFAULT
1515 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1516 #endif
1517 #endif
1518 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1519 #ifndef TARGET_BYTE_ORDER_DEFAULT
1520 /* compat - Catch old non byte-order selectable targets that do not
1521    define TARGET_BYTE_ORDER_DEFAULT and instead expect
1522    TARGET_BYTE_ORDER to be used as the default.  For targets that
1523    defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1524    below will get a strange compiler warning. */
1525 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1526 #endif
1527 #endif
1528 #ifndef TARGET_BYTE_ORDER_DEFAULT
1529 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1530 #endif
1531 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1532 int target_byte_order_auto = 1;
1533
1534 /* Chain containing the \"set endian\" commands.  */
1535 static struct cmd_list_element *endianlist = NULL;
1536
1537 /* Called by \`\`show endian''.  */
1538 static void
1539 show_endian (char *args, int from_tty)
1540 {
1541   char *msg =
1542     (TARGET_BYTE_ORDER_AUTO
1543      ? "The target endianness is set automatically (currently %s endian)\n"
1544      : "The target is assumed to be %s endian\n");
1545   printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1546 }
1547
1548 /* Called if the user enters \`\`set endian'' without an argument.  */
1549 static void
1550 set_endian (char *args, int from_tty)
1551 {
1552   printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1553   show_endian (args, from_tty);
1554 }
1555
1556 /* Called by \`\`set endian big''.  */
1557 static void
1558 set_endian_big (char *args, int from_tty)
1559 {
1560   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1561     {
1562       target_byte_order = BIG_ENDIAN;
1563       target_byte_order_auto = 0;
1564       if (GDB_MULTI_ARCH)
1565         {
1566           struct gdbarch_info info;
1567           memset (&info, 0, sizeof info);
1568           info.byte_order = BIG_ENDIAN;
1569           gdbarch_update (info);
1570         }
1571     }
1572   else
1573     {
1574       printf_unfiltered ("Byte order is not selectable.");
1575       show_endian (args, from_tty);
1576     }
1577 }
1578
1579 /* Called by \`\`set endian little''.  */
1580 static void
1581 set_endian_little (char *args, int from_tty)
1582 {
1583   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1584     {
1585       target_byte_order = LITTLE_ENDIAN;
1586       target_byte_order_auto = 0;
1587       if (GDB_MULTI_ARCH)
1588         {
1589           struct gdbarch_info info;
1590           memset (&info, 0, sizeof info);
1591           info.byte_order = LITTLE_ENDIAN;
1592           gdbarch_update (info);
1593         }
1594     }
1595   else
1596     {
1597       printf_unfiltered ("Byte order is not selectable.");
1598       show_endian (args, from_tty);
1599     }
1600 }
1601
1602 /* Called by \`\`set endian auto''.  */
1603 static void
1604 set_endian_auto (char *args, int from_tty)
1605 {
1606   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1607     {
1608       target_byte_order_auto = 1;
1609     }
1610   else
1611     {
1612       printf_unfiltered ("Byte order is not selectable.");
1613       show_endian (args, from_tty);
1614     }
1615 }
1616
1617 /* Set the endianness from a BFD.  */
1618 static void
1619 set_endian_from_file (bfd *abfd)
1620 {
1621   if (TARGET_BYTE_ORDER_SELECTABLE_P)
1622     {
1623       int want;
1624
1625       if (bfd_big_endian (abfd))
1626         want = BIG_ENDIAN;
1627       else
1628         want = LITTLE_ENDIAN;
1629       if (TARGET_BYTE_ORDER_AUTO)
1630         target_byte_order = want;
1631       else if (TARGET_BYTE_ORDER != want)
1632         warning ("%s endian file does not match %s endian target.",
1633                  want == BIG_ENDIAN ? "big" : "little",
1634                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1635     }
1636   else
1637     {
1638       if (bfd_big_endian (abfd)
1639           ? TARGET_BYTE_ORDER != BIG_ENDIAN
1640           : TARGET_BYTE_ORDER == BIG_ENDIAN)
1641         warning ("%s endian file does not match %s endian target.",
1642                  bfd_big_endian (abfd) ? "big" : "little",
1643                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1644     }
1645 }
1646
1647
1648
1649 /* Functions to manipulate the architecture of the target */
1650
1651 enum set_arch { set_arch_auto, set_arch_manual };
1652
1653 int target_architecture_auto = 1;
1654 extern const struct bfd_arch_info bfd_default_arch_struct;
1655 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1656 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1657
1658 static void show_endian (char *, int);
1659 static void set_endian (char *, int);
1660 static void set_endian_big (char *, int);
1661 static void set_endian_little (char *, int);
1662 static void set_endian_auto (char *, int);
1663 static void set_endian_from_file (bfd *);
1664 static int arch_ok (const struct bfd_arch_info *arch);
1665 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1666 static void show_architecture (char *, int);
1667 static void set_architecture (char *, int);
1668 static void info_architecture (char *, int);
1669 static void set_architecture_from_file (bfd *);
1670
1671 /* Do the real work of changing the current architecture */
1672
1673 static int
1674 arch_ok (const struct bfd_arch_info *arch)
1675 {
1676   /* Should be performing the more basic check that the binary is
1677      compatible with GDB. */
1678   /* Check with the target that the architecture is valid. */
1679   return (target_architecture_hook == NULL
1680           || target_architecture_hook (arch));
1681 }
1682
1683 static void
1684 set_arch (const struct bfd_arch_info *arch,
1685           enum set_arch type)
1686 {
1687   switch (type)
1688     {
1689     case set_arch_auto:
1690       if (!arch_ok (arch))
1691         warning ("Target may not support %s architecture",
1692                  arch->printable_name);
1693       target_architecture = arch;
1694       break;
1695     case set_arch_manual:
1696       if (!arch_ok (arch))
1697         {
1698           printf_unfiltered ("Target does not support \`%s' architecture.\n",
1699                              arch->printable_name);
1700         }
1701       else
1702         {
1703           target_architecture_auto = 0;
1704           target_architecture = arch;
1705         }
1706       break;
1707     }
1708   if (gdbarch_debug)
1709     gdbarch_dump ();
1710 }
1711
1712 /* Called if the user enters \`\`show architecture'' without an argument. */
1713 static void
1714 show_architecture (char *args, int from_tty)
1715 {
1716   const char *arch;
1717   arch = TARGET_ARCHITECTURE->printable_name;
1718   if (target_architecture_auto)
1719     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1720   else
1721     printf_filtered ("The target architecture is assumed to be %s\n", arch);
1722 }
1723
1724 /* Called if the user enters \`\`set architecture'' with or without an
1725    argument. */
1726 static void
1727 set_architecture (char *args, int from_tty)
1728 {
1729   if (args == NULL)
1730     {
1731       printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1732     }
1733   else if (strcmp (args, "auto") == 0)
1734     {
1735       target_architecture_auto = 1;
1736     }
1737   else if (GDB_MULTI_ARCH)
1738     {
1739       const struct bfd_arch_info *arch = bfd_scan_arch (args);
1740       if (arch == NULL)
1741         printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1742       else
1743         {
1744           struct gdbarch_info info;
1745           memset (&info, 0, sizeof info);
1746           info.bfd_arch_info = arch;
1747           if (gdbarch_update (info))
1748             target_architecture_auto = 0;
1749           else
1750             printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1751         }
1752     }
1753   else
1754     {
1755       const struct bfd_arch_info *arch = bfd_scan_arch (args);
1756       if (arch != NULL)
1757         set_arch (arch, set_arch_manual);
1758       else
1759         printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1760     }
1761 }
1762
1763 /* Called if the user enters \`\`info architecture'' without an argument. */
1764 static void
1765 info_architecture (char *args, int from_tty)
1766 {
1767   enum bfd_architecture a;
1768   if (GDB_MULTI_ARCH)
1769     {
1770       if (gdbarch_init_registrary != NULL)
1771         {
1772           struct gdbarch_init_registration *rego;
1773           printf_filtered ("Available architectures are:\n");
1774           for (rego = gdbarch_init_registrary;
1775                rego != NULL;
1776                rego = rego->next)
1777             {
1778               const struct bfd_arch_info *ap;
1779               ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1780               if (ap != NULL)
1781                 {
1782                   do
1783                     {
1784                       printf_filtered (" %s", ap->printable_name);
1785                       ap = ap->next;
1786                     }
1787                   while (ap != NULL);
1788                   printf_filtered ("\n");
1789                 }
1790             }
1791         }
1792       else
1793         {
1794           printf_filtered ("There are no available architectures.\n");
1795         }
1796       return;
1797     }
1798   printf_filtered ("Available architectures are:\n");
1799   for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1800     {
1801       const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1802       if (ap != NULL)
1803         {
1804           do
1805             {
1806               printf_filtered (" %s", ap->printable_name);
1807               ap = ap->next;
1808             }
1809           while (ap != NULL);
1810           printf_filtered ("\n");
1811         }
1812     }
1813 }
1814
1815 /* Set the architecture from arch/machine */
1816 void
1817 set_architecture_from_arch_mach (arch, mach)
1818      enum bfd_architecture arch;
1819      unsigned long mach;
1820 {
1821   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1822   if (wanted != NULL)
1823     set_arch (wanted, set_arch_manual);
1824   else
1825     internal_error ("gdbarch: hardwired architecture/machine not reconized");
1826 }
1827
1828 /* Set the architecture from a BFD */
1829 static void
1830 set_architecture_from_file (bfd *abfd)
1831 {
1832   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1833   if (target_architecture_auto)
1834     {
1835       set_arch (wanted, set_arch_auto);
1836     }
1837   else if (wanted != target_architecture)
1838     {
1839       warning ("%s architecture file may be incompatible with %s target.",
1840                wanted->printable_name,
1841                target_architecture->printable_name);
1842     }
1843 }
1844
1845
1846 /* Misc helper functions for targets. */
1847
1848 int
1849 frame_num_args_unknown (fi)
1850      struct frame_info *fi;
1851 {
1852   return -1;
1853 }
1854
1855
1856 int
1857 generic_register_convertible_not (num)
1858      int num;
1859 {
1860   return 0;
1861 }
1862
1863 /* Disassembler */
1864
1865 /* Pointer to the target-dependent disassembly function.  */
1866 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1867 disassemble_info tm_print_insn_info;
1868
1869
1870
1871 /* Set the dynamic target-system-dependant parameters (architecture,
1872    byte-order) using information found in the BFD */
1873
1874 void
1875 set_gdbarch_from_file (abfd)
1876      bfd *abfd;
1877 {
1878   if (GDB_MULTI_ARCH)
1879     {
1880       struct gdbarch_info info;
1881       memset (&info, 0, sizeof info);
1882       info.abfd = abfd;
1883       gdbarch_update (info);
1884       return;
1885     }
1886   set_architecture_from_file (abfd);
1887   set_endian_from_file (abfd);
1888 }
1889
1890
1891 #if defined (CALL_DUMMY)
1892 /* FIXME - this should go away */
1893 LONGEST call_dummy_words[] = CALL_DUMMY;
1894 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1895 #endif
1896
1897
1898 /* Initialize the current architecture.  */
1899 void
1900 initialize_current_architecture ()
1901 {
1902   if (GDB_MULTI_ARCH)
1903     {
1904       struct gdbarch_init_registration *rego;
1905       const struct bfd_arch_info *chosen = NULL;
1906       for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
1907         {
1908           const struct bfd_arch_info *ap
1909             = bfd_lookup_arch (rego->bfd_architecture, 0);
1910
1911           /* Choose the first architecture alphabetically.  */
1912           if (chosen == NULL
1913               || strcmp (ap->printable_name, chosen->printable_name) < 0)
1914             chosen = ap;
1915         }
1916
1917       if (chosen != NULL)
1918         {
1919           struct gdbarch_info info;
1920           memset (&info, 0, sizeof info);
1921           info.bfd_arch_info = chosen;
1922           gdbarch_update (info);
1923         }
1924     }
1925 }
1926
1927 extern void _initialize_gdbarch (void);
1928 void
1929 _initialize_gdbarch ()
1930 {
1931   add_prefix_cmd ("endian", class_support, set_endian,
1932                   "Set endianness of target.",
1933                   &endianlist, "set endian ", 0, &setlist);
1934   add_cmd ("big", class_support, set_endian_big,
1935            "Set target as being big endian.", &endianlist);
1936   add_cmd ("little", class_support, set_endian_little,
1937            "Set target as being little endian.", &endianlist);
1938   add_cmd ("auto", class_support, set_endian_auto,
1939            "Select target endianness automatically.", &endianlist);
1940   add_cmd ("endian", class_support, show_endian,
1941            "Show endianness of target.", &showlist);
1942
1943   add_cmd ("architecture", class_support, set_architecture,
1944            "Set architecture of target.", &setlist);
1945   add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
1946   add_cmd ("architecture", class_support, show_architecture,
1947            "Show architecture of target.", &showlist);
1948   add_cmd ("architecture", class_support, info_architecture,
1949            "List supported target architectures", &infolist);
1950
1951   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1952   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1953   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1954   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1955   tm_print_insn_info.print_address_func = dis_asm_print_address;
1956
1957   add_show_from_set (add_set_cmd ("archdebug",
1958                                   class_maintenance,
1959                                   var_zinteger,
1960                                   (char *)&gdbarch_debug,
1961                                   "Set architecture debugging.\n\\
1962 When non-zero, architecture debugging is enabled.", &setlist),
1963                      &showlist);
1964 }
1965 EOF
1966
1967 # close things off
1968 exec 1>&2
1969 #../move-if-change new-gdbarch.c gdbarch.c
1970 if ! test -r gdbarch.c
1971 then
1972   echo "gdbarch.c missing? cp new-gdbarch.c gdbarch.c" 1>&2
1973 elif diff -c gdbarch.c new-gdbarch.c
1974 then
1975   echo "gdbarch.c unchanged" 1>&2
1976 else
1977   echo "gdbarch.c has changed? cp new-gdbarch.c gdbarch.c" 1>&2
1978 fi