gdb/gdbarch.h

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