gdb/gdbarch.sh

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