gdb/gdbarch.h

   1 /* Architecture commands for GDB, the GNU debugger.
   2    Copyright 1998-1999, Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #ifndef GDBARCH_H
  22 #define GDBARCH_H
  23
  24 #ifdef __STDC__
  25 struct frame_info;
  26 struct value;
  27 enum lval_type;
  28 #endif
  29
  30
  31 #ifndef GDB_MULTI_ARCH
  32 #define GDB_MULTI_ARCH 0
  33 #endif
  34
  35 extern struct gdbarch *current_gdbarch;
  36
  37
  38 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
  39    macro */
  40
  41
  42 /* If any of the following are defined, the target wasn't correctly
  43    converted. */
  44
  45 #if GDB_MULTI_ARCH
  46 #if defined (CALL_DUMMY)
  47 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
  48 #endif
  49 #endif
  50
  51 #if GDB_MULTI_ARCH
  52 #if defined (REGISTER_NAMES)
  53 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
  54 #endif
  55 #endif
  56
  57 #if GDB_MULTI_ARCH
  58 #if defined (EXTRA_FRAME_INFO)
  59 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
  60 #endif
  61 #endif
  62
  63 #if GDB_MULTI_ARCH
  64 #if defined (FRAME_FIND_SAVED_REGS)
  65 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
  66 #endif
  67 #endif
  68
  69
  70 /* The following are pre-initialized by GDBARCH. */
  71
  72 extern const struct bfd_arch_info *gdbarch_bfd_arch_info PARAMS ((struct gdbarch * gdbarch));
  73 /* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
  74 #if GDB_MULTI_ARCH
  75 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_ARCHITECTURE)
  76 #define TARGET_ARCHITECTURE (gdbarch_bfd_arch_info (current_gdbarch))
  77 #endif
  78 #endif
  79
  80 extern int gdbarch_byte_order PARAMS ((struct gdbarch * gdbarch));
  81 /* set_gdbarch_byte_order() - not applicable - pre-initialized. */
  82 #if GDB_MULTI_ARCH
  83 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_BYTE_ORDER)
  84 #define TARGET_BYTE_ORDER (gdbarch_byte_order (current_gdbarch))
  85 #endif
  86 #endif
  87
  88
  89 /* The following are initialized by the target dependant code. */
  90
  91 extern int gdbarch_ptr_bit PARAMS ((struct gdbarch * gdbarch));
  92 extern void set_gdbarch_ptr_bit PARAMS ((struct gdbarch * gdbarch, int ptr_bit));
  93 #if GDB_MULTI_ARCH
  94 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_PTR_BIT)
  95 #define TARGET_PTR_BIT (gdbarch_ptr_bit (current_gdbarch))
  96 #endif
  97 #endif
  98
  99 extern int gdbarch_short_bit PARAMS ((struct gdbarch * gdbarch));
 100 extern void set_gdbarch_short_bit PARAMS ((struct gdbarch * gdbarch, int short_bit));
 101 #if GDB_MULTI_ARCH
 102 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_SHORT_BIT)
 103 #define TARGET_SHORT_BIT (gdbarch_short_bit (current_gdbarch))
 104 #endif
 105 #endif
 106
 107 extern int gdbarch_int_bit PARAMS ((struct gdbarch * gdbarch));
 108 extern void set_gdbarch_int_bit PARAMS ((struct gdbarch * gdbarch, int int_bit));
 109 #if GDB_MULTI_ARCH
 110 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_INT_BIT)
 111 #define TARGET_INT_BIT (gdbarch_int_bit (current_gdbarch))
 112 #endif
 113 #endif
 114
 115 extern int gdbarch_long_bit PARAMS ((struct gdbarch * gdbarch));
 116 extern void set_gdbarch_long_bit PARAMS ((struct gdbarch * gdbarch, int long_bit));
 117 #if GDB_MULTI_ARCH
 118 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_BIT)
 119 #define TARGET_LONG_BIT (gdbarch_long_bit (current_gdbarch))
 120 #endif
 121 #endif
 122
 123 extern int gdbarch_long_long_bit PARAMS ((struct gdbarch * gdbarch));
 124 extern void set_gdbarch_long_long_bit PARAMS ((struct gdbarch * gdbarch, int long_long_bit));
 125 #if GDB_MULTI_ARCH
 126 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_LONG_BIT)
 127 #define TARGET_LONG_LONG_BIT (gdbarch_long_long_bit (current_gdbarch))
 128 #endif
 129 #endif
 130
 131 extern int gdbarch_float_bit PARAMS ((struct gdbarch * gdbarch));
 132 extern void set_gdbarch_float_bit PARAMS ((struct gdbarch * gdbarch, int float_bit));
 133 #if GDB_MULTI_ARCH
 134 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_FLOAT_BIT)
 135 #define TARGET_FLOAT_BIT (gdbarch_float_bit (current_gdbarch))
 136 #endif
 137 #endif
 138
 139 extern int gdbarch_double_bit PARAMS ((struct gdbarch * gdbarch));
 140 extern void set_gdbarch_double_bit PARAMS ((struct gdbarch * gdbarch, int double_bit));
 141 #if GDB_MULTI_ARCH
 142 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_DOUBLE_BIT)
 143 #define TARGET_DOUBLE_BIT (gdbarch_double_bit (current_gdbarch))
 144 #endif
 145 #endif
 146
 147 extern int gdbarch_long_double_bit PARAMS ((struct gdbarch * gdbarch));
 148 extern void set_gdbarch_long_double_bit PARAMS ((struct gdbarch * gdbarch, int long_double_bit));
 149 #if GDB_MULTI_ARCH
 150 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_DOUBLE_BIT)
 151 #define TARGET_LONG_DOUBLE_BIT (gdbarch_long_double_bit (current_gdbarch))
 152 #endif
 153 #endif
 154
 155 typedef
 156 CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 157      extern CORE_ADDR gdbarch_read_pc PARAMS ((struct gdbarch * gdbarch, int pid));
 158      extern void set_gdbarch_read_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_read_pc_ftype * read_pc));
 159 #if GDB_MULTI_ARCH
 160 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_PC)
 161 #define TARGET_READ_PC(pid) (gdbarch_read_pc (current_gdbarch, pid))
 162 #endif
 163 #endif
 164
 165      typedef void (gdbarch_write_pc_ftype) PARAMS ((CORE_ADDR val, int pid));
 166      extern void gdbarch_write_pc PARAMS ((struct gdbarch * gdbarch, CORE_ADDR val, int pid));
 167      extern void set_gdbarch_write_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_write_pc_ftype * write_pc));
 168 #if GDB_MULTI_ARCH
 169 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_PC)
 170 #define TARGET_WRITE_PC(val, pid) (gdbarch_write_pc (current_gdbarch, val, pid))
 171 #endif
 172 #endif
 173
 174      typedef CORE_ADDR (gdbarch_read_fp_ftype) PARAMS ((void));
 175      extern CORE_ADDR gdbarch_read_fp PARAMS ((struct gdbarch * gdbarch));
 176      extern void set_gdbarch_read_fp PARAMS ((struct gdbarch * gdbarch, gdbarch_read_fp_ftype * read_fp));
 177 #if GDB_MULTI_ARCH
 178 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_FP)
 179 #define TARGET_READ_FP() (gdbarch_read_fp (current_gdbarch))
 180 #endif
 181 #endif
 182
 183      typedef void (gdbarch_write_fp_ftype) PARAMS ((CORE_ADDR val));
 184      extern void gdbarch_write_fp PARAMS ((struct gdbarch * gdbarch, CORE_ADDR val));
 185      extern void set_gdbarch_write_fp PARAMS ((struct gdbarch * gdbarch, gdbarch_write_fp_ftype * write_fp));
 186 #if GDB_MULTI_ARCH
 187 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_FP)
 188 #define TARGET_WRITE_FP(val) (gdbarch_write_fp (current_gdbarch, val))
 189 #endif
 190 #endif
 191
 192      typedef CORE_ADDR (gdbarch_read_sp_ftype) PARAMS ((void));
 193      extern CORE_ADDR gdbarch_read_sp PARAMS ((struct gdbarch * gdbarch));
 194      extern void set_gdbarch_read_sp PARAMS ((struct gdbarch * gdbarch, gdbarch_read_sp_ftype * read_sp));
 195 #if GDB_MULTI_ARCH
 196 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_SP)
 197 #define TARGET_READ_SP() (gdbarch_read_sp (current_gdbarch))
 198 #endif
 199 #endif
 200
 201      typedef void (gdbarch_write_sp_ftype) PARAMS ((CORE_ADDR val));
 202      extern void gdbarch_write_sp PARAMS ((struct gdbarch * gdbarch, CORE_ADDR val));
 203      extern void set_gdbarch_write_sp PARAMS ((struct gdbarch * gdbarch, gdbarch_write_sp_ftype * write_sp));
 204 #if GDB_MULTI_ARCH
 205 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_SP)
 206 #define TARGET_WRITE_SP(val) (gdbarch_write_sp (current_gdbarch, val))
 207 #endif
 208 #endif
 209
 210      extern int gdbarch_num_regs PARAMS ((struct gdbarch * gdbarch));
 211      extern void set_gdbarch_num_regs PARAMS ((struct gdbarch * gdbarch, int num_regs));
 212 #if GDB_MULTI_ARCH
 213 #if (GDB_MULTI_ARCH > 1) || !defined (NUM_REGS)
 214 #define NUM_REGS (gdbarch_num_regs (current_gdbarch))
 215 #endif
 216 #endif
 217
 218      extern int gdbarch_sp_regnum PARAMS ((struct gdbarch * gdbarch));
 219      extern void set_gdbarch_sp_regnum PARAMS ((struct gdbarch * gdbarch, int sp_regnum));
 220 #if GDB_MULTI_ARCH
 221 #if (GDB_MULTI_ARCH > 1) || !defined (SP_REGNUM)
 222 #define SP_REGNUM (gdbarch_sp_regnum (current_gdbarch))
 223 #endif
 224 #endif
 225
 226      extern int gdbarch_fp_regnum PARAMS ((struct gdbarch * gdbarch));
 227      extern void set_gdbarch_fp_regnum PARAMS ((struct gdbarch * gdbarch, int fp_regnum));
 228 #if GDB_MULTI_ARCH
 229 #if (GDB_MULTI_ARCH > 1) || !defined (FP_REGNUM)
 230 #define FP_REGNUM (gdbarch_fp_regnum (current_gdbarch))
 231 #endif
 232 #endif
 233
 234      extern int gdbarch_pc_regnum PARAMS ((struct gdbarch * gdbarch));
 235      extern void set_gdbarch_pc_regnum PARAMS ((struct gdbarch * gdbarch, int pc_regnum));
 236 #if GDB_MULTI_ARCH
 237 #if (GDB_MULTI_ARCH > 1) || !defined (PC_REGNUM)
 238 #define PC_REGNUM (gdbarch_pc_regnum (current_gdbarch))
 239 #endif
 240 #endif
 241
 242      typedef char *(gdbarch_register_name_ftype) PARAMS ((int regnr));
 243      extern char *gdbarch_register_name PARAMS ((struct gdbarch * gdbarch, int regnr));
 244      extern void set_gdbarch_register_name PARAMS ((struct gdbarch * gdbarch, gdbarch_register_name_ftype * register_name));
 245 #if GDB_MULTI_ARCH
 246 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_NAME)
 247 #define REGISTER_NAME(regnr) (gdbarch_register_name (current_gdbarch, regnr))
 248 #endif
 249 #endif
 250
 251      extern int gdbarch_register_size PARAMS ((struct gdbarch * gdbarch));
 252      extern void set_gdbarch_register_size PARAMS ((struct gdbarch * gdbarch, int register_size));
 253 #if GDB_MULTI_ARCH
 254 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_SIZE)
 255 #define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
 256 #endif
 257 #endif
 258
 259      extern int gdbarch_register_bytes PARAMS ((struct gdbarch * gdbarch));
 260      extern void set_gdbarch_register_bytes PARAMS ((struct gdbarch * gdbarch, int register_bytes));
 261 #if GDB_MULTI_ARCH
 262 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_BYTES)
 263 #define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch))
 264 #endif
 265 #endif
 266
 267      typedef int (gdbarch_register_byte_ftype) PARAMS ((int reg_nr));
 268      extern int gdbarch_register_byte PARAMS ((struct gdbarch * gdbarch, int reg_nr));
 269      extern void set_gdbarch_register_byte PARAMS ((struct gdbarch * gdbarch, gdbarch_register_byte_ftype * register_byte));
 270 #if GDB_MULTI_ARCH
 271 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_BYTE)
 272 #define REGISTER_BYTE(reg_nr) (gdbarch_register_byte (current_gdbarch, reg_nr))
 273 #endif
 274 #endif
 275
 276      typedef int (gdbarch_register_raw_size_ftype) PARAMS ((int reg_nr));
 277      extern int gdbarch_register_raw_size PARAMS ((struct gdbarch * gdbarch, int reg_nr));
 278      extern void set_gdbarch_register_raw_size PARAMS ((struct gdbarch * gdbarch, gdbarch_register_raw_size_ftype * register_raw_size));
 279 #if GDB_MULTI_ARCH
 280 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_RAW_SIZE)
 281 #define REGISTER_RAW_SIZE(reg_nr) (gdbarch_register_raw_size (current_gdbarch, reg_nr))
 282 #endif
 283 #endif
 284
 285      extern int gdbarch_max_register_raw_size PARAMS ((struct gdbarch * gdbarch));
 286      extern void set_gdbarch_max_register_raw_size PARAMS ((struct gdbarch * gdbarch, int max_register_raw_size));
 287 #if GDB_MULTI_ARCH
 288 #if (GDB_MULTI_ARCH > 1) || !defined (MAX_REGISTER_RAW_SIZE)
 289 #define MAX_REGISTER_RAW_SIZE (gdbarch_max_register_raw_size (current_gdbarch))
 290 #endif
 291 #endif
 292
 293      typedef int (gdbarch_register_virtual_size_ftype) PARAMS ((int reg_nr));
 294      extern int gdbarch_register_virtual_size PARAMS ((struct gdbarch * gdbarch, int reg_nr));
 295      extern void set_gdbarch_register_virtual_size PARAMS ((struct gdbarch * gdbarch, gdbarch_register_virtual_size_ftype * register_virtual_size));
 296 #if GDB_MULTI_ARCH
 297 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_VIRTUAL_SIZE)
 298 #define REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_register_virtual_size (current_gdbarch, reg_nr))
 299 #endif
 300 #endif
 301
 302      extern int gdbarch_max_register_virtual_size PARAMS ((struct gdbarch * gdbarch));
 303      extern void set_gdbarch_max_register_virtual_size PARAMS ((struct gdbarch * gdbarch, int max_register_virtual_size));
 304 #if GDB_MULTI_ARCH
 305 #if (GDB_MULTI_ARCH > 1) || !defined (MAX_REGISTER_VIRTUAL_SIZE)
 306 #define MAX_REGISTER_VIRTUAL_SIZE (gdbarch_max_register_virtual_size (current_gdbarch))
 307 #endif
 308 #endif
 309
 310      typedef struct type *(gdbarch_register_virtual_type_ftype) PARAMS ((int reg_nr));
 311      extern struct type *gdbarch_register_virtual_type PARAMS ((struct gdbarch * gdbarch, int reg_nr));
 312      extern void set_gdbarch_register_virtual_type PARAMS ((struct gdbarch * gdbarch, gdbarch_register_virtual_type_ftype * register_virtual_type));
 313 #if GDB_MULTI_ARCH
 314 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_VIRTUAL_TYPE)
 315 #define REGISTER_VIRTUAL_TYPE(reg_nr) (gdbarch_register_virtual_type (current_gdbarch, reg_nr))
 316 #endif
 317 #endif
 318
 319      extern int gdbarch_use_generic_dummy_frames PARAMS ((struct gdbarch * gdbarch));
 320      extern void set_gdbarch_use_generic_dummy_frames PARAMS ((struct gdbarch * gdbarch, int use_generic_dummy_frames));
 321 #if GDB_MULTI_ARCH
 322 #if (GDB_MULTI_ARCH > 1) || !defined (USE_GENERIC_DUMMY_FRAMES)
 323 #define USE_GENERIC_DUMMY_FRAMES (gdbarch_use_generic_dummy_frames (current_gdbarch))
 324 #endif
 325 #endif
 326
 327      extern int gdbarch_call_dummy_location PARAMS ((struct gdbarch * gdbarch));
 328      extern void set_gdbarch_call_dummy_location PARAMS ((struct gdbarch * gdbarch, int call_dummy_location));
 329 #if GDB_MULTI_ARCH
 330 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_LOCATION)
 331 #define CALL_DUMMY_LOCATION (gdbarch_call_dummy_location (current_gdbarch))
 332 #endif
 333 #endif
 334
 335      typedef CORE_ADDR (gdbarch_call_dummy_address_ftype) PARAMS ((void));
 336      extern CORE_ADDR gdbarch_call_dummy_address PARAMS ((struct gdbarch * gdbarch));
 337      extern void set_gdbarch_call_dummy_address PARAMS ((struct gdbarch * gdbarch, gdbarch_call_dummy_address_ftype * call_dummy_address));
 338 #if GDB_MULTI_ARCH
 339 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_ADDRESS)
 340 #define CALL_DUMMY_ADDRESS() (gdbarch_call_dummy_address (current_gdbarch))
 341 #endif
 342 #endif
 343
 344      extern CORE_ADDR gdbarch_call_dummy_start_offset PARAMS ((struct gdbarch * gdbarch));
 345      extern void set_gdbarch_call_dummy_start_offset PARAMS ((struct gdbarch * gdbarch, CORE_ADDR call_dummy_start_offset));
 346 #if GDB_MULTI_ARCH
 347 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_START_OFFSET)
 348 #define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
 349 #endif
 350 #endif
 351
 352      extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset PARAMS ((struct gdbarch * gdbarch));
 353      extern void set_gdbarch_call_dummy_breakpoint_offset PARAMS ((struct gdbarch * gdbarch, CORE_ADDR call_dummy_breakpoint_offset));
 354 #if GDB_MULTI_ARCH
 355 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
 356 #define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
 357 #endif
 358 #endif
 359
 360      extern int gdbarch_call_dummy_breakpoint_offset_p PARAMS ((struct gdbarch * gdbarch));
 361      extern void set_gdbarch_call_dummy_breakpoint_offset_p PARAMS ((struct gdbarch * gdbarch, int call_dummy_breakpoint_offset_p));
 362 #if GDB_MULTI_ARCH
 363 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET_P)
 364 #define CALL_DUMMY_BREAKPOINT_OFFSET_P (gdbarch_call_dummy_breakpoint_offset_p (current_gdbarch))
 365 #endif
 366 #endif
 367
 368      extern int gdbarch_call_dummy_length PARAMS ((struct gdbarch * gdbarch));
 369      extern void set_gdbarch_call_dummy_length PARAMS ((struct gdbarch * gdbarch, int call_dummy_length));
 370 #if GDB_MULTI_ARCH
 371 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_LENGTH)
 372 #define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
 373 #endif
 374 #endif
 375
 376      typedef int (gdbarch_pc_in_call_dummy_ftype) PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
 377      extern int gdbarch_pc_in_call_dummy PARAMS ((struct gdbarch * gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
 378      extern void set_gdbarch_pc_in_call_dummy PARAMS ((struct gdbarch * gdbarch, gdbarch_pc_in_call_dummy_ftype * pc_in_call_dummy));
 379 #if GDB_MULTI_ARCH
 380 #if (GDB_MULTI_ARCH > 1) || !defined (PC_IN_CALL_DUMMY)
 381 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) (gdbarch_pc_in_call_dummy (current_gdbarch, pc, sp, frame_address))
 382 #endif
 383 #endif
 384
 385      extern int gdbarch_call_dummy_p PARAMS ((struct gdbarch * gdbarch));
 386      extern void set_gdbarch_call_dummy_p PARAMS ((struct gdbarch * gdbarch, int call_dummy_p));
 387 #if GDB_MULTI_ARCH
 388 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_P)
 389 #define CALL_DUMMY_P (gdbarch_call_dummy_p (current_gdbarch))
 390 #endif
 391 #endif
 392
 393      extern LONGEST *gdbarch_call_dummy_words PARAMS ((struct gdbarch * gdbarch));
 394      extern void set_gdbarch_call_dummy_words PARAMS ((struct gdbarch * gdbarch, LONGEST * call_dummy_words));
 395 #if GDB_MULTI_ARCH
 396 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_WORDS)
 397 #define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
 398 #endif
 399 #endif
 400
 401      extern int gdbarch_sizeof_call_dummy_words PARAMS ((struct gdbarch * gdbarch));
 402      extern void set_gdbarch_sizeof_call_dummy_words PARAMS ((struct gdbarch * gdbarch, int sizeof_call_dummy_words));
 403 #if GDB_MULTI_ARCH
 404 #if (GDB_MULTI_ARCH > 1) || !defined (SIZEOF_CALL_DUMMY_WORDS)
 405 #define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
 406 #endif
 407 #endif
 408
 409      extern int gdbarch_call_dummy_stack_adjust_p PARAMS ((struct gdbarch * gdbarch));
 410      extern void set_gdbarch_call_dummy_stack_adjust_p PARAMS ((struct gdbarch * gdbarch, int call_dummy_stack_adjust_p));
 411 #if GDB_MULTI_ARCH
 412 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_STACK_ADJUST_P)
 413 #define CALL_DUMMY_STACK_ADJUST_P (gdbarch_call_dummy_stack_adjust_p (current_gdbarch))
 414 #endif
 415 #endif
 416
 417      extern int gdbarch_call_dummy_stack_adjust PARAMS ((struct gdbarch * gdbarch));
 418      extern void set_gdbarch_call_dummy_stack_adjust PARAMS ((struct gdbarch * gdbarch, int call_dummy_stack_adjust));
 419 #if GDB_MULTI_ARCH
 420 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_STACK_ADJUST)
 421 #define CALL_DUMMY_STACK_ADJUST (gdbarch_call_dummy_stack_adjust (current_gdbarch))
 422 #endif
 423 #endif
 424
 425      typedef void (gdbarch_fix_call_dummy_ftype) PARAMS ((char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value ** args, struct type * type, int gcc_p));
 426      extern void gdbarch_fix_call_dummy PARAMS ((struct gdbarch * gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value ** args, struct type * type, int gcc_p));
 427      extern void set_gdbarch_fix_call_dummy PARAMS ((struct gdbarch * gdbarch, gdbarch_fix_call_dummy_ftype * fix_call_dummy));
 428 #if GDB_MULTI_ARCH
 429 #if (GDB_MULTI_ARCH > 1) || !defined (FIX_CALL_DUMMY)
 430 #define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
 431 #endif
 432 #endif
 433
 434      extern int gdbarch_believe_pcc_promotion PARAMS ((struct gdbarch * gdbarch));
 435      extern void set_gdbarch_believe_pcc_promotion PARAMS ((struct gdbarch * gdbarch, int believe_pcc_promotion));
 436 #if GDB_MULTI_ARCH
 437 #if (GDB_MULTI_ARCH > 1) || !defined (BELIEVE_PCC_PROMOTION)
 438 #define BELIEVE_PCC_PROMOTION (gdbarch_believe_pcc_promotion (current_gdbarch))
 439 #endif
 440 #endif
 441
 442      extern int gdbarch_believe_pcc_promotion_type PARAMS ((struct gdbarch * gdbarch));
 443      extern void set_gdbarch_believe_pcc_promotion_type PARAMS ((struct gdbarch * gdbarch, int believe_pcc_promotion_type));
 444 #if GDB_MULTI_ARCH
 445 #if (GDB_MULTI_ARCH > 1) || !defined (BELIEVE_PCC_PROMOTION_TYPE)
 446 #define BELIEVE_PCC_PROMOTION_TYPE (gdbarch_believe_pcc_promotion_type (current_gdbarch))
 447 #endif
 448 #endif
 449
 450      typedef void (gdbarch_get_saved_register_ftype) PARAMS ((char *raw_buffer, int *optimized, CORE_ADDR * addrp, struct frame_info * frame, int regnum, enum lval_type * lval));
 451      extern void gdbarch_get_saved_register PARAMS ((struct gdbarch * gdbarch, char *raw_buffer, int *optimized, CORE_ADDR * addrp, struct frame_info * frame, int regnum, enum lval_type * lval));
 452      extern void set_gdbarch_get_saved_register PARAMS ((struct gdbarch * gdbarch, gdbarch_get_saved_register_ftype * get_saved_register));
 453 #if GDB_MULTI_ARCH
 454 #if (GDB_MULTI_ARCH > 1) || !defined (GET_SAVED_REGISTER)
 455 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) (gdbarch_get_saved_register (current_gdbarch, raw_buffer, optimized, addrp, frame, regnum, lval))
 456 #endif
 457 #endif
 458
 459      typedef int (gdbarch_register_convertible_ftype) PARAMS ((int nr));
 460      extern int gdbarch_register_convertible PARAMS ((struct gdbarch * gdbarch, int nr));
 461      extern void set_gdbarch_register_convertible PARAMS ((struct gdbarch * gdbarch, gdbarch_register_convertible_ftype * register_convertible));
 462 #if GDB_MULTI_ARCH
 463 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERTIBLE)
 464 #define REGISTER_CONVERTIBLE(nr) (gdbarch_register_convertible (current_gdbarch, nr))
 465 #endif
 466 #endif
 467
 468      typedef void (gdbarch_register_convert_to_virtual_ftype) PARAMS ((int regnum, struct type * type, char *from, char *to));
 469      extern void gdbarch_register_convert_to_virtual PARAMS ((struct gdbarch * gdbarch, int regnum, struct type * type, char *from, char *to));
 470      extern void set_gdbarch_register_convert_to_virtual PARAMS ((struct gdbarch * gdbarch, gdbarch_register_convert_to_virtual_ftype * register_convert_to_virtual));
 471 #if GDB_MULTI_ARCH
 472 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERT_TO_VIRTUAL)
 473 #define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (gdbarch_register_convert_to_virtual (current_gdbarch, regnum, type, from, to))
 474 #endif
 475 #endif
 476
 477      typedef void (gdbarch_register_convert_to_raw_ftype) PARAMS ((struct type * type, int regnum, char *from, char *to));
 478      extern void gdbarch_register_convert_to_raw PARAMS ((struct gdbarch * gdbarch, struct type * type, int regnum, char *from, char *to));
 479      extern void set_gdbarch_register_convert_to_raw PARAMS ((struct gdbarch * gdbarch, gdbarch_register_convert_to_raw_ftype * register_convert_to_raw));
 480 #if GDB_MULTI_ARCH
 481 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERT_TO_RAW)
 482 #define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (gdbarch_register_convert_to_raw (current_gdbarch, type, regnum, from, to))
 483 #endif
 484 #endif
 485
 486      typedef void (gdbarch_extract_return_value_ftype) PARAMS ((struct type * type, char *regbuf, char *valbuf));
 487      extern void gdbarch_extract_return_value PARAMS ((struct gdbarch * gdbarch, struct type * type, char *regbuf, char *valbuf));
 488      extern void set_gdbarch_extract_return_value PARAMS ((struct gdbarch * gdbarch, gdbarch_extract_return_value_ftype * extract_return_value));
 489 #if GDB_MULTI_ARCH
 490 #if (GDB_MULTI_ARCH > 1) || !defined (EXTRACT_RETURN_VALUE)
 491 #define EXTRACT_RETURN_VALUE(type, regbuf, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regbuf, valbuf))
 492 #endif
 493 #endif
 494
 495      typedef CORE_ADDR (gdbarch_push_arguments_ftype) PARAMS ((int nargs, struct value ** args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr));
 496      extern CORE_ADDR gdbarch_push_arguments PARAMS ((struct gdbarch * gdbarch, int nargs, struct value ** args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr));
 497      extern void set_gdbarch_push_arguments PARAMS ((struct gdbarch * gdbarch, gdbarch_push_arguments_ftype * push_arguments));
 498 #if GDB_MULTI_ARCH
 499 #if (GDB_MULTI_ARCH > 1) || !defined (PUSH_ARGUMENTS)
 500 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) (gdbarch_push_arguments (current_gdbarch, nargs, args, sp, struct_return, struct_addr))
 501 #endif
 502 #endif
 503
 504      typedef void (gdbarch_push_dummy_frame_ftype) PARAMS ((void));
 505      extern void gdbarch_push_dummy_frame PARAMS ((struct gdbarch * gdbarch));
 506      extern void set_gdbarch_push_dummy_frame PARAMS ((struct gdbarch * gdbarch, gdbarch_push_dummy_frame_ftype * push_dummy_frame));
 507 #if GDB_MULTI_ARCH
 508 #if (GDB_MULTI_ARCH > 1) || !defined (PUSH_DUMMY_FRAME)
 509 #define PUSH_DUMMY_FRAME (gdbarch_push_dummy_frame (current_gdbarch))
 510 #endif
 511 #endif
 512
 513      typedef CORE_ADDR (gdbarch_push_return_address_ftype) PARAMS ((CORE_ADDR pc, CORE_ADDR sp));
 514      extern CORE_ADDR gdbarch_push_return_address PARAMS ((struct gdbarch * gdbarch, CORE_ADDR pc, CORE_ADDR sp));
 515      extern void set_gdbarch_push_return_address PARAMS ((struct gdbarch * gdbarch, gdbarch_push_return_address_ftype * push_return_address));
 516 #if GDB_MULTI_ARCH
 517 #if (GDB_MULTI_ARCH > 1) || !defined (PUSH_RETURN_ADDRESS)
 518 #define PUSH_RETURN_ADDRESS(pc, sp) (gdbarch_push_return_address (current_gdbarch, pc, sp))
 519 #endif
 520 #endif
 521
 522      typedef void (gdbarch_pop_frame_ftype) PARAMS ((void));
 523      extern void gdbarch_pop_frame PARAMS ((struct gdbarch * gdbarch));
 524      extern void set_gdbarch_pop_frame PARAMS ((struct gdbarch * gdbarch, gdbarch_pop_frame_ftype * pop_frame));
 525 #if GDB_MULTI_ARCH
 526 #if (GDB_MULTI_ARCH > 1) || !defined (POP_FRAME)
 527 #define POP_FRAME (gdbarch_pop_frame (current_gdbarch))
 528 #endif
 529 #endif
 530
 531      typedef CORE_ADDR (gdbarch_d10v_make_daddr_ftype) PARAMS ((CORE_ADDR x));
 532      extern CORE_ADDR gdbarch_d10v_make_daddr PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
 533      extern void set_gdbarch_d10v_make_daddr PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_make_daddr_ftype * d10v_make_daddr));
 534 #if GDB_MULTI_ARCH
 535 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_MAKE_DADDR)
 536 #define D10V_MAKE_DADDR(x) (gdbarch_d10v_make_daddr (current_gdbarch, x))
 537 #endif
 538 #endif
 539
 540      typedef CORE_ADDR (gdbarch_d10v_make_iaddr_ftype) PARAMS ((CORE_ADDR x));
 541      extern CORE_ADDR gdbarch_d10v_make_iaddr PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
 542      extern void set_gdbarch_d10v_make_iaddr PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_make_iaddr_ftype * d10v_make_iaddr));
 543 #if GDB_MULTI_ARCH
 544 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_MAKE_IADDR)
 545 #define D10V_MAKE_IADDR(x) (gdbarch_d10v_make_iaddr (current_gdbarch, x))
 546 #endif
 547 #endif
 548
 549      typedef int (gdbarch_d10v_daddr_p_ftype) PARAMS ((CORE_ADDR x));
 550      extern int gdbarch_d10v_daddr_p PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
 551      extern void set_gdbarch_d10v_daddr_p PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_daddr_p_ftype * d10v_daddr_p));
 552 #if GDB_MULTI_ARCH
 553 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_DADDR_P)
 554 #define D10V_DADDR_P(x) (gdbarch_d10v_daddr_p (current_gdbarch, x))
 555 #endif
 556 #endif
 557
 558      typedef int (gdbarch_d10v_iaddr_p_ftype) PARAMS ((CORE_ADDR x));
 559      extern int gdbarch_d10v_iaddr_p PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
 560      extern void set_gdbarch_d10v_iaddr_p PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_iaddr_p_ftype * d10v_iaddr_p));
 561 #if GDB_MULTI_ARCH
 562 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_IADDR_P)
 563 #define D10V_IADDR_P(x) (gdbarch_d10v_iaddr_p (current_gdbarch, x))
 564 #endif
 565 #endif
 566
 567      typedef CORE_ADDR (gdbarch_d10v_convert_daddr_to_raw_ftype) PARAMS ((CORE_ADDR x));
 568      extern CORE_ADDR gdbarch_d10v_convert_daddr_to_raw PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
 569      extern void set_gdbarch_d10v_convert_daddr_to_raw PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_convert_daddr_to_raw_ftype * d10v_convert_daddr_to_raw));
 570 #if GDB_MULTI_ARCH
 571 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_CONVERT_DADDR_TO_RAW)
 572 #define D10V_CONVERT_DADDR_TO_RAW(x) (gdbarch_d10v_convert_daddr_to_raw (current_gdbarch, x))
 573 #endif
 574 #endif
 575
 576      typedef CORE_ADDR (gdbarch_d10v_convert_iaddr_to_raw_ftype) PARAMS ((CORE_ADDR x));
 577      extern CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
 578      extern void set_gdbarch_d10v_convert_iaddr_to_raw PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_convert_iaddr_to_raw_ftype * d10v_convert_iaddr_to_raw));
 579 #if GDB_MULTI_ARCH
 580 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_CONVERT_IADDR_TO_RAW)
 581 #define D10V_CONVERT_IADDR_TO_RAW(x) (gdbarch_d10v_convert_iaddr_to_raw (current_gdbarch, x))
 582 #endif
 583 #endif
 584
 585      typedef void (gdbarch_store_struct_return_ftype) PARAMS ((CORE_ADDR addr, CORE_ADDR sp));
 586      extern void gdbarch_store_struct_return PARAMS ((struct gdbarch * gdbarch, CORE_ADDR addr, CORE_ADDR sp));
 587      extern void set_gdbarch_store_struct_return PARAMS ((struct gdbarch * gdbarch, gdbarch_store_struct_return_ftype * store_struct_return));
 588 #if GDB_MULTI_ARCH
 589 #if (GDB_MULTI_ARCH > 1) || !defined (STORE_STRUCT_RETURN)
 590 #define STORE_STRUCT_RETURN(addr, sp) (gdbarch_store_struct_return (current_gdbarch, addr, sp))
 591 #endif
 592 #endif
 593
 594      typedef void (gdbarch_store_return_value_ftype) PARAMS ((struct type * type, char *valbuf));
 595      extern void gdbarch_store_return_value PARAMS ((struct gdbarch * gdbarch, struct type * type, char *valbuf));
 596      extern void set_gdbarch_store_return_value PARAMS ((struct gdbarch * gdbarch, gdbarch_store_return_value_ftype * store_return_value));
 597 #if GDB_MULTI_ARCH
 598 #if (GDB_MULTI_ARCH > 1) || !defined (STORE_RETURN_VALUE)
 599 #define STORE_RETURN_VALUE(type, valbuf) (gdbarch_store_return_value (current_gdbarch, type, valbuf))
 600 #endif
 601 #endif
 602
 603      typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) PARAMS ((char *regbuf));
 604      extern CORE_ADDR gdbarch_extract_struct_value_address PARAMS ((struct gdbarch * gdbarch, char *regbuf));
 605      extern void set_gdbarch_extract_struct_value_address PARAMS ((struct gdbarch * gdbarch, gdbarch_extract_struct_value_address_ftype * extract_struct_value_address));
 606 #if GDB_MULTI_ARCH
 607 #if (GDB_MULTI_ARCH > 1) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
 608 #define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (gdbarch_extract_struct_value_address (current_gdbarch, regbuf))
 609 #endif
 610 #endif
 611
 612      typedef int (gdbarch_use_struct_convention_ftype) PARAMS ((int gcc_p, struct type * value_type));
 613      extern int gdbarch_use_struct_convention PARAMS ((struct gdbarch * gdbarch, int gcc_p, struct type * value_type));
 614      extern void set_gdbarch_use_struct_convention PARAMS ((struct gdbarch * gdbarch, gdbarch_use_struct_convention_ftype * use_struct_convention));
 615 #if GDB_MULTI_ARCH
 616 #if (GDB_MULTI_ARCH > 1) || !defined (USE_STRUCT_CONVENTION)
 617 #define USE_STRUCT_CONVENTION(gcc_p, value_type) (gdbarch_use_struct_convention (current_gdbarch, gcc_p, value_type))
 618 #endif
 619 #endif
 620
 621      typedef void (gdbarch_frame_init_saved_regs_ftype) PARAMS ((struct frame_info * frame));
 622      extern void gdbarch_frame_init_saved_regs PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
 623      extern void set_gdbarch_frame_init_saved_regs PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_init_saved_regs_ftype * frame_init_saved_regs));
 624 #if GDB_MULTI_ARCH
 625 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_INIT_SAVED_REGS)
 626 #define FRAME_INIT_SAVED_REGS(frame) (gdbarch_frame_init_saved_regs (current_gdbarch, frame))
 627 #endif
 628 #endif
 629
 630      typedef void (gdbarch_init_extra_frame_info_ftype) PARAMS ((int fromleaf, struct frame_info * frame));
 631      extern void gdbarch_init_extra_frame_info PARAMS ((struct gdbarch * gdbarch, int fromleaf, struct frame_info * frame));
 632      extern void set_gdbarch_init_extra_frame_info PARAMS ((struct gdbarch * gdbarch, gdbarch_init_extra_frame_info_ftype * init_extra_frame_info));
 633 #if GDB_MULTI_ARCH
 634 #if (GDB_MULTI_ARCH > 1) || !defined (INIT_EXTRA_FRAME_INFO)
 635 #define INIT_EXTRA_FRAME_INFO(fromleaf, frame) (gdbarch_init_extra_frame_info (current_gdbarch, fromleaf, frame))
 636 #endif
 637 #endif
 638
 639      typedef CORE_ADDR (gdbarch_skip_prologue_ftype) PARAMS ((CORE_ADDR ip));
 640      extern CORE_ADDR gdbarch_skip_prologue PARAMS ((struct gdbarch * gdbarch, CORE_ADDR ip));
 641      extern void set_gdbarch_skip_prologue PARAMS ((struct gdbarch * gdbarch, gdbarch_skip_prologue_ftype * skip_prologue));
 642 #if GDB_MULTI_ARCH
 643 #if (GDB_MULTI_ARCH > 1) || !defined (SKIP_PROLOGUE)
 644 #define SKIP_PROLOGUE(ip) (gdbarch_skip_prologue (current_gdbarch, ip))
 645 #endif
 646 #endif
 647
 648      typedef int (gdbarch_inner_than_ftype) PARAMS ((CORE_ADDR lhs, CORE_ADDR rhs));
 649      extern int gdbarch_inner_than PARAMS ((struct gdbarch * gdbarch, CORE_ADDR lhs, CORE_ADDR rhs));
 650      extern void set_gdbarch_inner_than PARAMS ((struct gdbarch * gdbarch, gdbarch_inner_than_ftype * inner_than));
 651 #if GDB_MULTI_ARCH
 652 #if (GDB_MULTI_ARCH > 1) || !defined (INNER_THAN)
 653 #define INNER_THAN(lhs, rhs) (gdbarch_inner_than (current_gdbarch, lhs, rhs))
 654 #endif
 655 #endif
 656
 657      typedef unsigned char *(gdbarch_breakpoint_from_pc_ftype) PARAMS ((CORE_ADDR * pcptr, int *lenptr));
 658      extern unsigned char *gdbarch_breakpoint_from_pc PARAMS ((struct gdbarch * gdbarch, CORE_ADDR * pcptr, int *lenptr));
 659      extern void set_gdbarch_breakpoint_from_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_breakpoint_from_pc_ftype * breakpoint_from_pc));
 660 #if GDB_MULTI_ARCH
 661 #if (GDB_MULTI_ARCH > 1) || !defined (BREAKPOINT_FROM_PC)
 662 #define BREAKPOINT_FROM_PC(pcptr, lenptr) (gdbarch_breakpoint_from_pc (current_gdbarch, pcptr, lenptr))
 663 #endif
 664 #endif
 665
 666      extern CORE_ADDR gdbarch_decr_pc_after_break PARAMS ((struct gdbarch * gdbarch));
 667      extern void set_gdbarch_decr_pc_after_break PARAMS ((struct gdbarch * gdbarch, CORE_ADDR decr_pc_after_break));
 668 #if GDB_MULTI_ARCH
 669 #if (GDB_MULTI_ARCH > 1) || !defined (DECR_PC_AFTER_BREAK)
 670 #define DECR_PC_AFTER_BREAK (gdbarch_decr_pc_after_break (current_gdbarch))
 671 #endif
 672 #endif
 673
 674      extern CORE_ADDR gdbarch_function_start_offset PARAMS ((struct gdbarch * gdbarch));
 675      extern void set_gdbarch_function_start_offset PARAMS ((struct gdbarch * gdbarch, CORE_ADDR function_start_offset));
 676 #if GDB_MULTI_ARCH
 677 #if (GDB_MULTI_ARCH > 1) || !defined (FUNCTION_START_OFFSET)
 678 #define FUNCTION_START_OFFSET (gdbarch_function_start_offset (current_gdbarch))
 679 #endif
 680 #endif
 681
 682      typedef void (gdbarch_remote_translate_xfer_address_ftype) PARAMS ((CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR * rem_addr, int *rem_len));
 683      extern void gdbarch_remote_translate_xfer_address PARAMS ((struct gdbarch * gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR * rem_addr, int *rem_len));
 684      extern void set_gdbarch_remote_translate_xfer_address PARAMS ((struct gdbarch * gdbarch, gdbarch_remote_translate_xfer_address_ftype * remote_translate_xfer_address));
 685 #if GDB_MULTI_ARCH
 686 #if (GDB_MULTI_ARCH > 1) || !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
 687 #define REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len) (gdbarch_remote_translate_xfer_address (current_gdbarch, gdb_addr, gdb_len, rem_addr, rem_len))
 688 #endif
 689 #endif
 690
 691      extern CORE_ADDR gdbarch_frame_args_skip PARAMS ((struct gdbarch * gdbarch));
 692      extern void set_gdbarch_frame_args_skip PARAMS ((struct gdbarch * gdbarch, CORE_ADDR frame_args_skip));
 693 #if GDB_MULTI_ARCH
 694 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_ARGS_SKIP)
 695 #define FRAME_ARGS_SKIP (gdbarch_frame_args_skip (current_gdbarch))
 696 #endif
 697 #endif
 698
 699      typedef int (gdbarch_frameless_function_invocation_ftype) PARAMS ((struct frame_info * fi));
 700      extern int gdbarch_frameless_function_invocation PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
 701      extern void set_gdbarch_frameless_function_invocation PARAMS ((struct gdbarch * gdbarch, gdbarch_frameless_function_invocation_ftype * frameless_function_invocation));
 702 #if GDB_MULTI_ARCH
 703 #if (GDB_MULTI_ARCH > 1) || !defined (FRAMELESS_FUNCTION_INVOCATION)
 704 #define FRAMELESS_FUNCTION_INVOCATION(fi) (gdbarch_frameless_function_invocation (current_gdbarch, fi))
 705 #endif
 706 #endif
 707
 708      typedef CORE_ADDR (gdbarch_frame_chain_ftype) PARAMS ((struct frame_info * frame));
 709      extern CORE_ADDR gdbarch_frame_chain PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
 710      extern void set_gdbarch_frame_chain PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_chain_ftype * frame_chain));
 711 #if GDB_MULTI_ARCH
 712 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_CHAIN)
 713 #define FRAME_CHAIN(frame) (gdbarch_frame_chain (current_gdbarch, frame))
 714 #endif
 715 #endif
 716
 717      typedef int (gdbarch_frame_chain_valid_ftype) PARAMS ((CORE_ADDR chain, struct frame_info * thisframe));
 718      extern int gdbarch_frame_chain_valid PARAMS ((struct gdbarch * gdbarch, CORE_ADDR chain, struct frame_info * thisframe));
 719      extern void set_gdbarch_frame_chain_valid PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_chain_valid_ftype * frame_chain_valid));
 720 #if GDB_MULTI_ARCH
 721 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_CHAIN_VALID)
 722 #define FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_frame_chain_valid (current_gdbarch, chain, thisframe))
 723 #endif
 724 #endif
 725
 726      typedef CORE_ADDR (gdbarch_frame_saved_pc_ftype) PARAMS ((struct frame_info * fi));
 727      extern CORE_ADDR gdbarch_frame_saved_pc PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
 728      extern void set_gdbarch_frame_saved_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_saved_pc_ftype * frame_saved_pc));
 729 #if GDB_MULTI_ARCH
 730 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_SAVED_PC)
 731 #define FRAME_SAVED_PC(fi) (gdbarch_frame_saved_pc (current_gdbarch, fi))
 732 #endif
 733 #endif
 734
 735      typedef CORE_ADDR (gdbarch_frame_args_address_ftype) PARAMS ((struct frame_info * fi));
 736      extern CORE_ADDR gdbarch_frame_args_address PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
 737      extern void set_gdbarch_frame_args_address PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_args_address_ftype * frame_args_address));
 738 #if GDB_MULTI_ARCH
 739 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_ARGS_ADDRESS)
 740 #define FRAME_ARGS_ADDRESS(fi) (gdbarch_frame_args_address (current_gdbarch, fi))
 741 #endif
 742 #endif
 743
 744      typedef CORE_ADDR (gdbarch_frame_locals_address_ftype) PARAMS ((struct frame_info * fi));
 745      extern CORE_ADDR gdbarch_frame_locals_address PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
 746      extern void set_gdbarch_frame_locals_address PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_locals_address_ftype * frame_locals_address));
 747 #if GDB_MULTI_ARCH
 748 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_LOCALS_ADDRESS)
 749 #define FRAME_LOCALS_ADDRESS(fi) (gdbarch_frame_locals_address (current_gdbarch, fi))
 750 #endif
 751 #endif
 752
 753      typedef CORE_ADDR (gdbarch_saved_pc_after_call_ftype) PARAMS ((struct frame_info * frame));
 754      extern CORE_ADDR gdbarch_saved_pc_after_call PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
 755      extern void set_gdbarch_saved_pc_after_call PARAMS ((struct gdbarch * gdbarch, gdbarch_saved_pc_after_call_ftype * saved_pc_after_call));
 756 #if GDB_MULTI_ARCH
 757 #if (GDB_MULTI_ARCH > 1) || !defined (SAVED_PC_AFTER_CALL)
 758 #define SAVED_PC_AFTER_CALL(frame) (gdbarch_saved_pc_after_call (current_gdbarch, frame))
 759 #endif
 760 #endif
 761
 762      typedef int (gdbarch_frame_num_args_ftype) PARAMS ((struct frame_info * frame));
 763      extern int gdbarch_frame_num_args PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
 764      extern void set_gdbarch_frame_num_args PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_num_args_ftype * frame_num_args));
 765 #if GDB_MULTI_ARCH
 766 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_NUM_ARGS)
 767 #define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame))
 768 #endif
 769 #endif
 770
 771      extern struct gdbarch_tdep *gdbarch_tdep PARAMS ((struct gdbarch * gdbarch));
 772
 773
 774 /* Mechanism for co-ordinating the selection of a specific
 775    architecture.
 776
 777    GDB targets (*-tdep.c) can register an interest in a specific
 778    architecture.  Other GDB components can register a need to maintain
 779    per-architecture data.
 780
 781    The mechanisms below ensures that there is only a loose connection
 782    between the set-architecture command and the various GDB
 783    components.  Each component can independantly register their need
 784    to maintain architecture specific data with gdbarch.
 785
 786    Pragmatics:
 787
 788    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
 789    didn't scale.
 790
 791    The more traditional mega-struct containing architecture specific
 792    data for all the various GDB components was also considered.  Since
 793    GDB is built from a variable number of (fairly independant)
 794    components it was determined that the global aproach was not
 795    applicable. */
 796
 797
 798 /* Register a new architectural family with GDB.
 799
 800    Register support for the specified ARCHITECTURE with GDB.  When
 801    gdbarch determines that the specified architecture has been
 802    selected, the corresponding INIT function is called.
 803
 804    --
 805
 806    The INIT function takes two parameters: INFO which contains the
 807    information available to gdbarch about the (possibly new)
 808    architecture; ARCHES which is a list of the previously created
 809    ``struct gdbarch'' for this architecture.
 810
 811    The INIT function parameter INFO shall, as far as possible, be
 812    pre-initialized with information obtained from INFO.ABFD or
 813    previously selected architecture (if similar).  INIT shall ensure
 814    that the INFO.BYTE_ORDER is non-zero.
 815
 816    The INIT function shall return any of: NULL - indicating that it
 817    doesn't reconize the selected architecture; an existing ``struct
 818    gdbarch'' from the ARCHES list - indicating that the new
 819    architecture is just a synonym for an earlier architecture (see
 820    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
 821    - that describes the selected architecture (see
 822    gdbarch_alloc()). */
 823
 824      struct gdbarch_list
 825        {
 826          struct gdbarch *gdbarch;
 827          struct gdbarch_list *next;
 828        };
 829
 830      struct gdbarch_info
 831        {
 832          /* Use default: bfd_arch_unknown (ZERO). */
 833          enum bfd_architecture bfd_architecture;
 834
 835          /* Use default: NULL (ZERO). */
 836          const struct bfd_arch_info *bfd_arch_info;
 837
 838          /* Use default: 0 (ZERO). */
 839          int byte_order;
 840
 841          /* Use default: NULL (ZERO). */
 842          bfd *abfd;
 843
 844          /* Use default: NULL (ZERO). */
 845          struct gdbarch_tdep_info *tdep_info;
 846        };
 847
 848      typedef struct gdbarch *(gdbarch_init_ftype) PARAMS ((struct gdbarch_info info, struct gdbarch_list * arches));
 849
 850      extern void register_gdbarch_init PARAMS ((enum bfd_architecture architecture, gdbarch_init_ftype *));
 851
 852
 853 /* Helper function.  Search the list of ARCHES for a GDBARCH that
 854    matches the information provided by INFO. */
 855
 856      extern struct gdbarch_list *gdbarch_list_lookup_by_info PARAMS ((struct gdbarch_list * arches, const struct gdbarch_info * info));
 857
 858
 859 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
 860    basic initialization using values obtained from the INFO andTDEP
 861    parameters.  set_gdbarch_*() functions are called to complete the
 862    initialization of the object. */
 863
 864      extern struct gdbarch *gdbarch_alloc PARAMS ((const struct gdbarch_info * info, struct gdbarch_tdep * tdep));
 865
 866
 867 /* Helper function. Force an update of the current architecture.  Used
 868    by legacy targets that have added their own target specific
 869    architecture manipulation commands.
 870
 871    The INFO parameter shall be fully initialized (``memset (&INFO,
 872    sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
 873    called.  gdbarch_update() shall initialize any ``default'' fields
 874    using information obtained from the previous architecture or
 875    INFO.ABFD (if specified) before calling the corresponding
 876    architectures INIT function. */
 877
 878      extern int gdbarch_update PARAMS ((struct gdbarch_info info));
 879
 880
 881
 882 /* Register per-architecture data-pointer.
 883
 884    Reserve space for a per-architecture data-pointer.  An identifier
 885    for the reserved data-pointer is returned.  That identifer should
 886    be saved in a local static.
 887
 888    When a new architecture is selected, INIT() is called.  When a
 889    previous architecture is re-selected, the per-architecture
 890    data-pointer for that previous architecture is restored (INIT() is
 891    not called).
 892
 893    INIT() shall return the initial value for the per-architecture
 894    data-pointer for the current architecture.
 895
 896    Multiple registrarants for any architecture are allowed (and
 897    strongly encouraged).  */
 898
 899      typedef void *(gdbarch_data_ftype) PARAMS ((void));
 900      extern struct gdbarch_data *register_gdbarch_data PARAMS ((gdbarch_data_ftype * init));
 901
 902 /* Return the value of the per-architecture data-pointer for the
 903    current architecture. */
 904
 905      extern void *gdbarch_data PARAMS ((struct gdbarch_data *));
 906
 907
 908
 909 /* Register per-architecture memory region.
 910
 911    Provide a memory-region swap mechanism.  Per-architecture memory
 912    region are created.  These memory regions are swapped whenever the
 913    architecture is changed.  For a new architecture, the memory region
 914    is initialized with zero (0) and the INIT function is called.
 915
 916    Memory regions are swapped / initialized in the order that they are
 917    registered.  NULL DATA and/or INIT values can be specified.
 918
 919    New code should use register_gdbarch_data(). */
 920
 921      typedef void (gdbarch_swap_ftype) PARAMS ((void));
 922      extern void register_gdbarch_swap PARAMS ((void *data, unsigned long size, gdbarch_swap_ftype * init));
 923
 924
 925
 926 /* The target-system-dependant byte order is dynamic */
 927
 928 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
 929    is selectable at runtime.  The user can use the ``set endian''
 930    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
 931    target_byte_order should be auto-detected (from the program image
 932    say). */
 933
 934 #if GDB_MULTI_ARCH
 935 /* Multi-arch GDB is always bi-endian. */
 936 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 937 #endif
 938
 939 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
 940 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
 941    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
 942 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 943 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
 944 #else
 945 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
 946 #endif
 947 #endif
 948
 949      extern int target_byte_order;
 950 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 951 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
 952    and expect defs.h to re-define TARGET_BYTE_ORDER. */
 953 #undef TARGET_BYTE_ORDER
 954 #endif
 955 #ifndef TARGET_BYTE_ORDER
 956 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 957 #endif
 958
 959      extern int target_byte_order_auto;
 960 #ifndef TARGET_BYTE_ORDER_AUTO
 961 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 962 #endif
 963
 964
 965
 966 /* The target-system-dependant BFD architecture is dynamic */
 967
 968      extern int target_architecture_auto;
 969 #ifndef TARGET_ARCHITECTURE_AUTO
 970 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 971 #endif
 972
 973      extern const struct bfd_arch_info *target_architecture;
 974 #ifndef TARGET_ARCHITECTURE
 975 #define TARGET_ARCHITECTURE (target_architecture + 0)
 976 #endif
 977
 978 /* Notify the target dependant backend of a change to the selected
 979    architecture. A zero return status indicates that the target did
 980    not like the change. */
 981
 982      extern int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *));
 983
 984
 985
 986 /* The target-system-dependant disassembler is semi-dynamic */
 987
 988 #include "dis-asm.h"            /* Get defs for disassemble_info */
 989
 990      extern int dis_asm_read_memory PARAMS ((bfd_vma memaddr, bfd_byte * myaddr,
 991                                          int len, disassemble_info * info));
 992
 993      extern void dis_asm_memory_error PARAMS ((int status, bfd_vma memaddr,
 994                                                disassemble_info * info));
 995
 996      extern void dis_asm_print_address PARAMS ((bfd_vma addr,
 997                                                 disassemble_info * info));
 998
 999      extern int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *));
1000      extern disassemble_info tm_print_insn_info;
1001 #ifndef TARGET_PRINT_INSN
1002 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
1003 #endif
1004 #ifndef TARGET_PRINT_INSN_INFO
1005 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1006 #endif
1007
1008
1009
1010 /* Explicit test for D10V architecture.
1011    USE of these macro's is *STRONGLY* discouraged. */
1012
1013 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
1014 #ifndef D10V_MAKE_DADDR
1015 #define D10V_MAKE_DADDR(X) (fatal ("gdbarch: D10V_MAKE_DADDR"), 0)
1016 #endif
1017 #ifndef D10V_MAKE_IADDR
1018 #define D10V_MAKE_IADDR(X) (fatal ("gdbarch: D10V_MAKE_IADDR"), 0)
1019 #endif
1020
1021
1022 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
1023 #ifndef FRAMELESS_FUNCTION_INVOCATION
1024 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
1025 #endif
1026
1027
1028 /* Fallback definition of REGISTER_CONVERTIBLE etc */
1029      extern int generic_register_convertible_not PARAMS ((int reg_nr));
1030 #ifndef REGISTER_CONVERTIBLE
1031 #define REGISTER_CONVERTIBLE(x) (0)
1032 #endif
1033 #ifndef REGISTER_CONVERT_TO_VIRTUAL
1034 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
1035 #endif
1036 #ifndef REGISTER_CONVERT_TO_RAW
1037 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
1038 #endif
1039
1040
1041 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
1042 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
1043 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
1044 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (fatal ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
1045 #else
1046 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
1047 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
1048 #endif
1049 #endif
1050
1051
1052 /* Fallback definition for REGISTER_NAME for systems still defining
1053    REGISTER_NAMES. */
1054 #ifndef REGISTER_NAME
1055      extern char *gdb_register_names[];
1056 #define REGISTER_NAME(i) gdb_register_names[i]
1057 #endif
1058
1059
1060 /* Set the dynamic target-system-dependant parameters (architecture,
1061    byte-order, ...) using information found in the BFD */
1062
1063      extern void set_gdbarch_from_file PARAMS ((bfd *));
1064
1065
1066 /* Explicitly set the dynamic target-system-dependant parameters based
1067    on bfd_architecture and machine. */
1068
1069      extern void set_architecture_from_arch_mach PARAMS ((enum bfd_architecture, unsigned long));
1070
1071
1072 /* Helper function for targets that don't know how my arguments are
1073    being passed */
1074
1075      extern int frame_num_args_unknown PARAMS ((struct frame_info * fi));
1076
1077
1078 /* gdbarch trace variable */
1079      extern int gdbarch_debug;
1080
1081      extern void gdbarch_dump PARAMS ((void));
1082
1083 #endif