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