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