gdb/gdbarch.h

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