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