gdb/gdbarch.h

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4    Copyright 1998, 1999, 2000, 2001, 2002, 2003 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 Bourne 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 making 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 #include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
  39 #if !GDB_MULTI_ARCH
  40 /* Pull in function declarations refered to, indirectly, via macros.  */
  41 #include "inferior.h"           /* For unsigned_address_to_pointer().  */
  42 #endif
  43
  44 struct frame_info;
  45 struct value;
  46 struct objfile;
  47 struct minimal_symbol;
  48 struct regcache;
  49 struct reggroup;
  50
  51 extern struct gdbarch *current_gdbarch;
  52
  53
  54 /* If any of the following are defined, the target wasn't correctly
  55    converted. */
  56
  57 #if GDB_MULTI_ARCH
  58 #if defined (EXTRA_FRAME_INFO)
  59 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
  60 #endif
  61 #endif
  62
  63 #if GDB_MULTI_ARCH
  64 #if defined (FRAME_FIND_SAVED_REGS)
  65 #error "FRAME_FIND_SAVED_REGS: replaced by DEPRECATED_FRAME_INIT_SAVED_REGS"
  66 #endif
  67 #endif
  68
  69 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
  70 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
  71 #endif
  72
  73
  74 /* The following are pre-initialized by GDBARCH. */
  75
  76 extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
  77 /* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
  78 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_ARCHITECTURE)
  79 #error "Non multi-arch definition of TARGET_ARCHITECTURE"
  80 #endif
  81 #if GDB_MULTI_ARCH
  82 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_ARCHITECTURE)
  83 #define TARGET_ARCHITECTURE (gdbarch_bfd_arch_info (current_gdbarch))
  84 #endif
  85 #endif
  86
  87 extern int gdbarch_byte_order (struct gdbarch *gdbarch);
  88 /* set_gdbarch_byte_order() - not applicable - pre-initialized. */
  89 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_BYTE_ORDER)
  90 #error "Non multi-arch definition of TARGET_BYTE_ORDER"
  91 #endif
  92 #if GDB_MULTI_ARCH
  93 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_BYTE_ORDER)
  94 #define TARGET_BYTE_ORDER (gdbarch_byte_order (current_gdbarch))
  95 #endif
  96 #endif
  97
  98 extern enum gdb_osabi gdbarch_osabi (struct gdbarch *gdbarch);
  99 /* set_gdbarch_osabi() - not applicable - pre-initialized. */
 100 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_OSABI)
 101 #error "Non multi-arch definition of TARGET_OSABI"
 102 #endif
 103 #if GDB_MULTI_ARCH
 104 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_OSABI)
 105 #define TARGET_OSABI (gdbarch_osabi (current_gdbarch))
 106 #endif
 107 #endif
 108
 109
 110 /* The following are initialized by the target dependent code. */
 111
 112 /* Number of bits in a char or unsigned char for the target machine.
 113    Just like CHAR_BIT in <limits.h> but describes the target machine.
 114    v:2:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
 115
 116    Number of bits in a short or unsigned short for the target machine. */
 117
 118 /* Default (value) for non- multi-arch platforms. */
 119 #if (!GDB_MULTI_ARCH) && !defined (TARGET_SHORT_BIT)
 120 #define TARGET_SHORT_BIT (2*TARGET_CHAR_BIT)
 121 #endif
 122
 123 extern int gdbarch_short_bit (struct gdbarch *gdbarch);
 124 extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
 125 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_SHORT_BIT)
 126 #error "Non multi-arch definition of TARGET_SHORT_BIT"
 127 #endif
 128 #if GDB_MULTI_ARCH
 129 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_SHORT_BIT)
 130 #define TARGET_SHORT_BIT (gdbarch_short_bit (current_gdbarch))
 131 #endif
 132 #endif
 133
 134 /* Number of bits in an int or unsigned int for the target machine. */
 135
 136 /* Default (value) for non- multi-arch platforms. */
 137 #if (!GDB_MULTI_ARCH) && !defined (TARGET_INT_BIT)
 138 #define TARGET_INT_BIT (4*TARGET_CHAR_BIT)
 139 #endif
 140
 141 extern int gdbarch_int_bit (struct gdbarch *gdbarch);
 142 extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
 143 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_INT_BIT)
 144 #error "Non multi-arch definition of TARGET_INT_BIT"
 145 #endif
 146 #if GDB_MULTI_ARCH
 147 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_INT_BIT)
 148 #define TARGET_INT_BIT (gdbarch_int_bit (current_gdbarch))
 149 #endif
 150 #endif
 151
 152 /* Number of bits in a long or unsigned long for the target machine. */
 153
 154 /* Default (value) for non- multi-arch platforms. */
 155 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_BIT)
 156 #define TARGET_LONG_BIT (4*TARGET_CHAR_BIT)
 157 #endif
 158
 159 extern int gdbarch_long_bit (struct gdbarch *gdbarch);
 160 extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
 161 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_LONG_BIT)
 162 #error "Non multi-arch definition of TARGET_LONG_BIT"
 163 #endif
 164 #if GDB_MULTI_ARCH
 165 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_BIT)
 166 #define TARGET_LONG_BIT (gdbarch_long_bit (current_gdbarch))
 167 #endif
 168 #endif
 169
 170 /* Number of bits in a long long or unsigned long long for the target
 171    machine. */
 172
 173 /* Default (value) for non- multi-arch platforms. */
 174 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_LONG_BIT)
 175 #define TARGET_LONG_LONG_BIT (2*TARGET_LONG_BIT)
 176 #endif
 177
 178 extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
 179 extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
 180 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_LONG_LONG_BIT)
 181 #error "Non multi-arch definition of TARGET_LONG_LONG_BIT"
 182 #endif
 183 #if GDB_MULTI_ARCH
 184 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_LONG_BIT)
 185 #define TARGET_LONG_LONG_BIT (gdbarch_long_long_bit (current_gdbarch))
 186 #endif
 187 #endif
 188
 189 /* Number of bits in a float for the target machine. */
 190
 191 /* Default (value) for non- multi-arch platforms. */
 192 #if (!GDB_MULTI_ARCH) && !defined (TARGET_FLOAT_BIT)
 193 #define TARGET_FLOAT_BIT (4*TARGET_CHAR_BIT)
 194 #endif
 195
 196 extern int gdbarch_float_bit (struct gdbarch *gdbarch);
 197 extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
 198 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_FLOAT_BIT)
 199 #error "Non multi-arch definition of TARGET_FLOAT_BIT"
 200 #endif
 201 #if GDB_MULTI_ARCH
 202 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_FLOAT_BIT)
 203 #define TARGET_FLOAT_BIT (gdbarch_float_bit (current_gdbarch))
 204 #endif
 205 #endif
 206
 207 /* Number of bits in a double for the target machine. */
 208
 209 /* Default (value) for non- multi-arch platforms. */
 210 #if (!GDB_MULTI_ARCH) && !defined (TARGET_DOUBLE_BIT)
 211 #define TARGET_DOUBLE_BIT (8*TARGET_CHAR_BIT)
 212 #endif
 213
 214 extern int gdbarch_double_bit (struct gdbarch *gdbarch);
 215 extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
 216 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_DOUBLE_BIT)
 217 #error "Non multi-arch definition of TARGET_DOUBLE_BIT"
 218 #endif
 219 #if GDB_MULTI_ARCH
 220 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_DOUBLE_BIT)
 221 #define TARGET_DOUBLE_BIT (gdbarch_double_bit (current_gdbarch))
 222 #endif
 223 #endif
 224
 225 /* Number of bits in a long double for the target machine. */
 226
 227 /* Default (value) for non- multi-arch platforms. */
 228 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_DOUBLE_BIT)
 229 #define TARGET_LONG_DOUBLE_BIT (8*TARGET_CHAR_BIT)
 230 #endif
 231
 232 extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
 233 extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
 234 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_LONG_DOUBLE_BIT)
 235 #error "Non multi-arch definition of TARGET_LONG_DOUBLE_BIT"
 236 #endif
 237 #if GDB_MULTI_ARCH
 238 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_DOUBLE_BIT)
 239 #define TARGET_LONG_DOUBLE_BIT (gdbarch_long_double_bit (current_gdbarch))
 240 #endif
 241 #endif
 242
 243 /* For most targets, a pointer on the target and its representation as an
 244    address in GDB have the same size and "look the same".  For such a
 245    target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
 246    / addr_bit will be set from it.
 247
 248    If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
 249    also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
 250
 251    ptr_bit is the size of a pointer on the target */
 252
 253 /* Default (value) for non- multi-arch platforms. */
 254 #if (!GDB_MULTI_ARCH) && !defined (TARGET_PTR_BIT)
 255 #define TARGET_PTR_BIT (TARGET_INT_BIT)
 256 #endif
 257
 258 extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
 259 extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
 260 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_PTR_BIT)
 261 #error "Non multi-arch definition of TARGET_PTR_BIT"
 262 #endif
 263 #if GDB_MULTI_ARCH
 264 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_PTR_BIT)
 265 #define TARGET_PTR_BIT (gdbarch_ptr_bit (current_gdbarch))
 266 #endif
 267 #endif
 268
 269 /* addr_bit is the size of a target address as represented in gdb */
 270
 271 /* Default (value) for non- multi-arch platforms. */
 272 #if (!GDB_MULTI_ARCH) && !defined (TARGET_ADDR_BIT)
 273 #define TARGET_ADDR_BIT (TARGET_PTR_BIT)
 274 #endif
 275
 276 extern int gdbarch_addr_bit (struct gdbarch *gdbarch);
 277 extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
 278 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_ADDR_BIT)
 279 #error "Non multi-arch definition of TARGET_ADDR_BIT"
 280 #endif
 281 #if GDB_MULTI_ARCH
 282 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_ADDR_BIT)
 283 #define TARGET_ADDR_BIT (gdbarch_addr_bit (current_gdbarch))
 284 #endif
 285 #endif
 286
 287 /* Number of bits in a BFD_VMA for the target object file format. */
 288
 289 /* Default (value) for non- multi-arch platforms. */
 290 #if (!GDB_MULTI_ARCH) && !defined (TARGET_BFD_VMA_BIT)
 291 #define TARGET_BFD_VMA_BIT (TARGET_ARCHITECTURE->bits_per_address)
 292 #endif
 293
 294 extern int gdbarch_bfd_vma_bit (struct gdbarch *gdbarch);
 295 extern void set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch, int bfd_vma_bit);
 296 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_BFD_VMA_BIT)
 297 #error "Non multi-arch definition of TARGET_BFD_VMA_BIT"
 298 #endif
 299 #if GDB_MULTI_ARCH
 300 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_BFD_VMA_BIT)
 301 #define TARGET_BFD_VMA_BIT (gdbarch_bfd_vma_bit (current_gdbarch))
 302 #endif
 303 #endif
 304
 305 /* One if `char' acts like `signed char', zero if `unsigned char'. */
 306
 307 /* Default (value) for non- multi-arch platforms. */
 308 #if (!GDB_MULTI_ARCH) && !defined (TARGET_CHAR_SIGNED)
 309 #define TARGET_CHAR_SIGNED (1)
 310 #endif
 311
 312 extern int gdbarch_char_signed (struct gdbarch *gdbarch);
 313 extern void set_gdbarch_char_signed (struct gdbarch *gdbarch, int char_signed);
 314 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_CHAR_SIGNED)
 315 #error "Non multi-arch definition of TARGET_CHAR_SIGNED"
 316 #endif
 317 #if GDB_MULTI_ARCH
 318 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_CHAR_SIGNED)
 319 #define TARGET_CHAR_SIGNED (gdbarch_char_signed (current_gdbarch))
 320 #endif
 321 #endif
 322
 323 /* Default (function) for non- multi-arch platforms. */
 324 #if (!GDB_MULTI_ARCH) && !defined (TARGET_READ_PC)
 325 #define TARGET_READ_PC(ptid) (generic_target_read_pc (ptid))
 326 #endif
 327
 328 typedef CORE_ADDR (gdbarch_read_pc_ftype) (ptid_t ptid);
 329 extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid);
 330 extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
 331 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_READ_PC)
 332 #error "Non multi-arch definition of TARGET_READ_PC"
 333 #endif
 334 #if GDB_MULTI_ARCH
 335 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_PC)
 336 #define TARGET_READ_PC(ptid) (gdbarch_read_pc (current_gdbarch, ptid))
 337 #endif
 338 #endif
 339
 340 /* Default (function) for non- multi-arch platforms. */
 341 #if (!GDB_MULTI_ARCH) && !defined (TARGET_WRITE_PC)
 342 #define TARGET_WRITE_PC(val, ptid) (generic_target_write_pc (val, ptid))
 343 #endif
 344
 345 typedef void (gdbarch_write_pc_ftype) (CORE_ADDR val, ptid_t ptid);
 346 extern void gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid);
 347 extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
 348 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_WRITE_PC)
 349 #error "Non multi-arch definition of TARGET_WRITE_PC"
 350 #endif
 351 #if GDB_MULTI_ARCH
 352 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_WRITE_PC)
 353 #define TARGET_WRITE_PC(val, ptid) (gdbarch_write_pc (current_gdbarch, val, ptid))
 354 #endif
 355 #endif
 356
 357 /* Default (function) for non- multi-arch platforms. */
 358 #if (!GDB_MULTI_ARCH) && !defined (TARGET_READ_FP)
 359 #define TARGET_READ_FP() (generic_target_read_fp ())
 360 #endif
 361
 362 typedef CORE_ADDR (gdbarch_read_fp_ftype) (void);
 363 extern CORE_ADDR gdbarch_read_fp (struct gdbarch *gdbarch);
 364 extern void set_gdbarch_read_fp (struct gdbarch *gdbarch, gdbarch_read_fp_ftype *read_fp);
 365 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_READ_FP)
 366 #error "Non multi-arch definition of TARGET_READ_FP"
 367 #endif
 368 #if GDB_MULTI_ARCH
 369 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_FP)
 370 #define TARGET_READ_FP() (gdbarch_read_fp (current_gdbarch))
 371 #endif
 372 #endif
 373
 374 /* Default (function) for non- multi-arch platforms. */
 375 #if (!GDB_MULTI_ARCH) && !defined (TARGET_READ_SP)
 376 #define TARGET_READ_SP() (generic_target_read_sp ())
 377 #endif
 378
 379 typedef CORE_ADDR (gdbarch_read_sp_ftype) (void);
 380 extern CORE_ADDR gdbarch_read_sp (struct gdbarch *gdbarch);
 381 extern void set_gdbarch_read_sp (struct gdbarch *gdbarch, gdbarch_read_sp_ftype *read_sp);
 382 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_READ_SP)
 383 #error "Non multi-arch definition of TARGET_READ_SP"
 384 #endif
 385 #if GDB_MULTI_ARCH
 386 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_SP)
 387 #define TARGET_READ_SP() (gdbarch_read_sp (current_gdbarch))
 388 #endif
 389 #endif
 390
 391 /* Default (function) for non- multi-arch platforms. */
 392 #if (!GDB_MULTI_ARCH) && !defined (TARGET_WRITE_SP)
 393 #define TARGET_WRITE_SP(val) (generic_target_write_sp (val))
 394 #endif
 395
 396 typedef void (gdbarch_write_sp_ftype) (CORE_ADDR val);
 397 extern void gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val);
 398 extern void set_gdbarch_write_sp (struct gdbarch *gdbarch, gdbarch_write_sp_ftype *write_sp);
 399 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_WRITE_SP)
 400 #error "Non multi-arch definition of TARGET_WRITE_SP"
 401 #endif
 402 #if GDB_MULTI_ARCH
 403 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_WRITE_SP)
 404 #define TARGET_WRITE_SP(val) (gdbarch_write_sp (current_gdbarch, val))
 405 #endif
 406 #endif
 407
 408 /* Function for getting target's idea of a frame pointer.  FIXME: GDB's
 409    whole scheme for dealing with "frames" and "frame pointers" needs a
 410    serious shakedown. */
 411
 412 /* Default (function) for non- multi-arch platforms. */
 413 #if (!GDB_MULTI_ARCH) && !defined (TARGET_VIRTUAL_FRAME_POINTER)
 414 #define TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset) (legacy_virtual_frame_pointer (pc, frame_regnum, frame_offset))
 415 #endif
 416
 417 typedef void (gdbarch_virtual_frame_pointer_ftype) (CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
 418 extern void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset);
 419 extern void set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer);
 420 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_VIRTUAL_FRAME_POINTER)
 421 #error "Non multi-arch definition of TARGET_VIRTUAL_FRAME_POINTER"
 422 #endif
 423 #if GDB_MULTI_ARCH
 424 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_VIRTUAL_FRAME_POINTER)
 425 #define TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset) (gdbarch_virtual_frame_pointer (current_gdbarch, pc, frame_regnum, frame_offset))
 426 #endif
 427 #endif
 428
 429 extern int gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch);
 430
 431 typedef void (gdbarch_pseudo_register_read_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf);
 432 extern void gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf);
 433 extern void set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read);
 434
 435 extern int gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch);
 436
 437 typedef void (gdbarch_pseudo_register_write_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf);
 438 extern void gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf);
 439 extern void set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write);
 440
 441 extern int gdbarch_num_regs (struct gdbarch *gdbarch);
 442 extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
 443 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (NUM_REGS)
 444 #error "Non multi-arch definition of NUM_REGS"
 445 #endif
 446 #if GDB_MULTI_ARCH
 447 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NUM_REGS)
 448 #define NUM_REGS (gdbarch_num_regs (current_gdbarch))
 449 #endif
 450 #endif
 451
 452 /* This macro gives the number of pseudo-registers that live in the
 453    register namespace but do not get fetched or stored on the target.
 454    These pseudo-registers may be aliases for other registers,
 455    combinations of other registers, or they may be computed by GDB. */
 456
 457 /* Default (value) for non- multi-arch platforms. */
 458 #if (!GDB_MULTI_ARCH) && !defined (NUM_PSEUDO_REGS)
 459 #define NUM_PSEUDO_REGS (0)
 460 #endif
 461
 462 extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch);
 463 extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs);
 464 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (NUM_PSEUDO_REGS)
 465 #error "Non multi-arch definition of NUM_PSEUDO_REGS"
 466 #endif
 467 #if GDB_MULTI_ARCH
 468 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NUM_PSEUDO_REGS)
 469 #define NUM_PSEUDO_REGS (gdbarch_num_pseudo_regs (current_gdbarch))
 470 #endif
 471 #endif
 472
 473 /* GDB's standard (or well known) register numbers.  These can map onto
 474    a real register or a pseudo (computed) register or not be defined at
 475    all (-1). */
 476
 477 /* Default (value) for non- multi-arch platforms. */
 478 #if (!GDB_MULTI_ARCH) && !defined (SP_REGNUM)
 479 #define SP_REGNUM (-1)
 480 #endif
 481
 482 extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
 483 extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
 484 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SP_REGNUM)
 485 #error "Non multi-arch definition of SP_REGNUM"
 486 #endif
 487 #if GDB_MULTI_ARCH
 488 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SP_REGNUM)
 489 #define SP_REGNUM (gdbarch_sp_regnum (current_gdbarch))
 490 #endif
 491 #endif
 492
 493 /* Default (value) for non- multi-arch platforms. */
 494 #if (!GDB_MULTI_ARCH) && !defined (FP_REGNUM)
 495 #define FP_REGNUM (-1)
 496 #endif
 497
 498 extern int gdbarch_fp_regnum (struct gdbarch *gdbarch);
 499 extern void set_gdbarch_fp_regnum (struct gdbarch *gdbarch, int fp_regnum);
 500 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FP_REGNUM)
 501 #error "Non multi-arch definition of FP_REGNUM"
 502 #endif
 503 #if GDB_MULTI_ARCH
 504 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FP_REGNUM)
 505 #define FP_REGNUM (gdbarch_fp_regnum (current_gdbarch))
 506 #endif
 507 #endif
 508
 509 /* Default (value) for non- multi-arch platforms. */
 510 #if (!GDB_MULTI_ARCH) && !defined (PC_REGNUM)
 511 #define PC_REGNUM (-1)
 512 #endif
 513
 514 extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
 515 extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
 516 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PC_REGNUM)
 517 #error "Non multi-arch definition of PC_REGNUM"
 518 #endif
 519 #if GDB_MULTI_ARCH
 520 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PC_REGNUM)
 521 #define PC_REGNUM (gdbarch_pc_regnum (current_gdbarch))
 522 #endif
 523 #endif
 524
 525 /* Default (value) for non- multi-arch platforms. */
 526 #if (!GDB_MULTI_ARCH) && !defined (PS_REGNUM)
 527 #define PS_REGNUM (-1)
 528 #endif
 529
 530 extern int gdbarch_ps_regnum (struct gdbarch *gdbarch);
 531 extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum);
 532 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PS_REGNUM)
 533 #error "Non multi-arch definition of PS_REGNUM"
 534 #endif
 535 #if GDB_MULTI_ARCH
 536 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PS_REGNUM)
 537 #define PS_REGNUM (gdbarch_ps_regnum (current_gdbarch))
 538 #endif
 539 #endif
 540
 541 /* Default (value) for non- multi-arch platforms. */
 542 #if (!GDB_MULTI_ARCH) && !defined (FP0_REGNUM)
 543 #define FP0_REGNUM (-1)
 544 #endif
 545
 546 extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
 547 extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
 548 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FP0_REGNUM)
 549 #error "Non multi-arch definition of FP0_REGNUM"
 550 #endif
 551 #if GDB_MULTI_ARCH
 552 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FP0_REGNUM)
 553 #define FP0_REGNUM (gdbarch_fp0_regnum (current_gdbarch))
 554 #endif
 555 #endif
 556
 557 /* Default (value) for non- multi-arch platforms. */
 558 #if (!GDB_MULTI_ARCH) && !defined (NPC_REGNUM)
 559 #define NPC_REGNUM (-1)
 560 #endif
 561
 562 extern int gdbarch_npc_regnum (struct gdbarch *gdbarch);
 563 extern void set_gdbarch_npc_regnum (struct gdbarch *gdbarch, int npc_regnum);
 564 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (NPC_REGNUM)
 565 #error "Non multi-arch definition of NPC_REGNUM"
 566 #endif
 567 #if GDB_MULTI_ARCH
 568 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NPC_REGNUM)
 569 #define NPC_REGNUM (gdbarch_npc_regnum (current_gdbarch))
 570 #endif
 571 #endif
 572
 573 /* Convert stab register number (from `r' declaration) to a gdb REGNUM. */
 574
 575 /* Default (function) for non- multi-arch platforms. */
 576 #if (!GDB_MULTI_ARCH) && !defined (STAB_REG_TO_REGNUM)
 577 #define STAB_REG_TO_REGNUM(stab_regnr) (no_op_reg_to_regnum (stab_regnr))
 578 #endif
 579
 580 typedef int (gdbarch_stab_reg_to_regnum_ftype) (int stab_regnr);
 581 extern int gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr);
 582 extern void set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum);
 583 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STAB_REG_TO_REGNUM)
 584 #error "Non multi-arch definition of STAB_REG_TO_REGNUM"
 585 #endif
 586 #if GDB_MULTI_ARCH
 587 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STAB_REG_TO_REGNUM)
 588 #define STAB_REG_TO_REGNUM(stab_regnr) (gdbarch_stab_reg_to_regnum (current_gdbarch, stab_regnr))
 589 #endif
 590 #endif
 591
 592 /* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
 593
 594 /* Default (function) for non- multi-arch platforms. */
 595 #if (!GDB_MULTI_ARCH) && !defined (ECOFF_REG_TO_REGNUM)
 596 #define ECOFF_REG_TO_REGNUM(ecoff_regnr) (no_op_reg_to_regnum (ecoff_regnr))
 597 #endif
 598
 599 typedef int (gdbarch_ecoff_reg_to_regnum_ftype) (int ecoff_regnr);
 600 extern int gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr);
 601 extern void set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum);
 602 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (ECOFF_REG_TO_REGNUM)
 603 #error "Non multi-arch definition of ECOFF_REG_TO_REGNUM"
 604 #endif
 605 #if GDB_MULTI_ARCH
 606 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ECOFF_REG_TO_REGNUM)
 607 #define ECOFF_REG_TO_REGNUM(ecoff_regnr) (gdbarch_ecoff_reg_to_regnum (current_gdbarch, ecoff_regnr))
 608 #endif
 609 #endif
 610
 611 /* Provide a default mapping from a DWARF register number to a gdb REGNUM. */
 612
 613 /* Default (function) for non- multi-arch platforms. */
 614 #if (!GDB_MULTI_ARCH) && !defined (DWARF_REG_TO_REGNUM)
 615 #define DWARF_REG_TO_REGNUM(dwarf_regnr) (no_op_reg_to_regnum (dwarf_regnr))
 616 #endif
 617
 618 typedef int (gdbarch_dwarf_reg_to_regnum_ftype) (int dwarf_regnr);
 619 extern int gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr);
 620 extern void set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum);
 621 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DWARF_REG_TO_REGNUM)
 622 #error "Non multi-arch definition of DWARF_REG_TO_REGNUM"
 623 #endif
 624 #if GDB_MULTI_ARCH
 625 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DWARF_REG_TO_REGNUM)
 626 #define DWARF_REG_TO_REGNUM(dwarf_regnr) (gdbarch_dwarf_reg_to_regnum (current_gdbarch, dwarf_regnr))
 627 #endif
 628 #endif
 629
 630 /* Convert from an sdb register number to an internal gdb register number.
 631    This should be defined in tm.h, if REGISTER_NAMES is not set up
 632    to map one to one onto the sdb register numbers. */
 633
 634 /* Default (function) for non- multi-arch platforms. */
 635 #if (!GDB_MULTI_ARCH) && !defined (SDB_REG_TO_REGNUM)
 636 #define SDB_REG_TO_REGNUM(sdb_regnr) (no_op_reg_to_regnum (sdb_regnr))
 637 #endif
 638
 639 typedef int (gdbarch_sdb_reg_to_regnum_ftype) (int sdb_regnr);
 640 extern int gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr);
 641 extern void set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum);
 642 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SDB_REG_TO_REGNUM)
 643 #error "Non multi-arch definition of SDB_REG_TO_REGNUM"
 644 #endif
 645 #if GDB_MULTI_ARCH
 646 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SDB_REG_TO_REGNUM)
 647 #define SDB_REG_TO_REGNUM(sdb_regnr) (gdbarch_sdb_reg_to_regnum (current_gdbarch, sdb_regnr))
 648 #endif
 649 #endif
 650
 651 /* Default (function) for non- multi-arch platforms. */
 652 #if (!GDB_MULTI_ARCH) && !defined (DWARF2_REG_TO_REGNUM)
 653 #define DWARF2_REG_TO_REGNUM(dwarf2_regnr) (no_op_reg_to_regnum (dwarf2_regnr))
 654 #endif
 655
 656 typedef int (gdbarch_dwarf2_reg_to_regnum_ftype) (int dwarf2_regnr);
 657 extern int gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr);
 658 extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum);
 659 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DWARF2_REG_TO_REGNUM)
 660 #error "Non multi-arch definition of DWARF2_REG_TO_REGNUM"
 661 #endif
 662 #if GDB_MULTI_ARCH
 663 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DWARF2_REG_TO_REGNUM)
 664 #define DWARF2_REG_TO_REGNUM(dwarf2_regnr) (gdbarch_dwarf2_reg_to_regnum (current_gdbarch, dwarf2_regnr))
 665 #endif
 666 #endif
 667
 668 /* Default (function) for non- multi-arch platforms. */
 669 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_NAME)
 670 #define REGISTER_NAME(regnr) (legacy_register_name (regnr))
 671 #endif
 672
 673 typedef const char * (gdbarch_register_name_ftype) (int regnr);
 674 extern const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
 675 extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
 676 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_NAME)
 677 #error "Non multi-arch definition of REGISTER_NAME"
 678 #endif
 679 #if GDB_MULTI_ARCH
 680 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_NAME)
 681 #define REGISTER_NAME(regnr) (gdbarch_register_name (current_gdbarch, regnr))
 682 #endif
 683 #endif
 684
 685 extern int gdbarch_register_size (struct gdbarch *gdbarch);
 686 extern void set_gdbarch_register_size (struct gdbarch *gdbarch, int register_size);
 687 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_SIZE)
 688 #error "Non multi-arch definition of REGISTER_SIZE"
 689 #endif
 690 #if GDB_MULTI_ARCH
 691 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_SIZE)
 692 #define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
 693 #endif
 694 #endif
 695
 696 extern int gdbarch_register_bytes (struct gdbarch *gdbarch);
 697 extern void set_gdbarch_register_bytes (struct gdbarch *gdbarch, int register_bytes);
 698 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTES)
 699 #error "Non multi-arch definition of REGISTER_BYTES"
 700 #endif
 701 #if GDB_MULTI_ARCH
 702 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTES)
 703 #define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch))
 704 #endif
 705 #endif
 706
 707 /* Default (function) for non- multi-arch platforms. */
 708 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_BYTE)
 709 #define REGISTER_BYTE(reg_nr) (generic_register_byte (reg_nr))
 710 #endif
 711
 712 typedef int (gdbarch_register_byte_ftype) (int reg_nr);
 713 extern int gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr);
 714 extern void set_gdbarch_register_byte (struct gdbarch *gdbarch, gdbarch_register_byte_ftype *register_byte);
 715 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTE)
 716 #error "Non multi-arch definition of REGISTER_BYTE"
 717 #endif
 718 #if GDB_MULTI_ARCH
 719 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTE)
 720 #define REGISTER_BYTE(reg_nr) (gdbarch_register_byte (current_gdbarch, reg_nr))
 721 #endif
 722 #endif
 723
 724 /* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
 725    MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
 726    REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
 727    by REGISTER_TYPE. */
 728
 729 /* Default (function) for non- multi-arch platforms. */
 730 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_RAW_SIZE)
 731 #define REGISTER_RAW_SIZE(reg_nr) (generic_register_size (reg_nr))
 732 #endif
 733
 734 typedef int (gdbarch_register_raw_size_ftype) (int reg_nr);
 735 extern int gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr);
 736 extern void set_gdbarch_register_raw_size (struct gdbarch *gdbarch, gdbarch_register_raw_size_ftype *register_raw_size);
 737 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_RAW_SIZE)
 738 #error "Non multi-arch definition of REGISTER_RAW_SIZE"
 739 #endif
 740 #if GDB_MULTI_ARCH
 741 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_RAW_SIZE)
 742 #define REGISTER_RAW_SIZE(reg_nr) (gdbarch_register_raw_size (current_gdbarch, reg_nr))
 743 #endif
 744 #endif
 745
 746 /* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
 747    MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
 748    REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
 749    by REGISTER_TYPE. */
 750
 751 extern int gdbarch_max_register_raw_size (struct gdbarch *gdbarch);
 752 extern void set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch, int max_register_raw_size);
 753 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (MAX_REGISTER_RAW_SIZE)
 754 #error "Non multi-arch definition of MAX_REGISTER_RAW_SIZE"
 755 #endif
 756 #if GDB_MULTI_ARCH
 757 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MAX_REGISTER_RAW_SIZE)
 758 #define MAX_REGISTER_RAW_SIZE (gdbarch_max_register_raw_size (current_gdbarch))
 759 #endif
 760 #endif
 761
 762 /* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
 763    MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
 764    REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
 765    by REGISTER_TYPE. */
 766
 767 /* Default (function) for non- multi-arch platforms. */
 768 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_VIRTUAL_SIZE)
 769 #define REGISTER_VIRTUAL_SIZE(reg_nr) (generic_register_size (reg_nr))
 770 #endif
 771
 772 typedef int (gdbarch_register_virtual_size_ftype) (int reg_nr);
 773 extern int gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr);
 774 extern void set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, gdbarch_register_virtual_size_ftype *register_virtual_size);
 775 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_VIRTUAL_SIZE)
 776 #error "Non multi-arch definition of REGISTER_VIRTUAL_SIZE"
 777 #endif
 778 #if GDB_MULTI_ARCH
 779 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_VIRTUAL_SIZE)
 780 #define REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_register_virtual_size (current_gdbarch, reg_nr))
 781 #endif
 782 #endif
 783
 784 /* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
 785    MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
 786    REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced
 787    by REGISTER_TYPE. */
 788
 789 extern int gdbarch_max_register_virtual_size (struct gdbarch *gdbarch);
 790 extern void set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch, int max_register_virtual_size);
 791 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (MAX_REGISTER_VIRTUAL_SIZE)
 792 #error "Non multi-arch definition of MAX_REGISTER_VIRTUAL_SIZE"
 793 #endif
 794 #if GDB_MULTI_ARCH
 795 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MAX_REGISTER_VIRTUAL_SIZE)
 796 #define MAX_REGISTER_VIRTUAL_SIZE (gdbarch_max_register_virtual_size (current_gdbarch))
 797 #endif
 798 #endif
 799
 800 /* The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
 801    MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE,
 802    REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE have all being replaced
 803    by REGISTER_TYPE. */
 804
 805 #if defined (REGISTER_VIRTUAL_TYPE)
 806 /* Legacy for systems yet to multi-arch REGISTER_VIRTUAL_TYPE */
 807 #if !defined (REGISTER_VIRTUAL_TYPE_P)
 808 #define REGISTER_VIRTUAL_TYPE_P() (1)
 809 #endif
 810 #endif
 811
 812 /* Default predicate for non- multi-arch targets. */
 813 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_VIRTUAL_TYPE_P)
 814 #define REGISTER_VIRTUAL_TYPE_P() (0)
 815 #endif
 816
 817 extern int gdbarch_register_virtual_type_p (struct gdbarch *gdbarch);
 818 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_VIRTUAL_TYPE_P)
 819 #error "Non multi-arch definition of REGISTER_VIRTUAL_TYPE"
 820 #endif
 821 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_VIRTUAL_TYPE_P)
 822 #define REGISTER_VIRTUAL_TYPE_P() (gdbarch_register_virtual_type_p (current_gdbarch))
 823 #endif
 824
 825 /* Default (function) for non- multi-arch platforms. */
 826 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_VIRTUAL_TYPE)
 827 #define REGISTER_VIRTUAL_TYPE(reg_nr) (internal_error (__FILE__, __LINE__, "REGISTER_VIRTUAL_TYPE"), 0)
 828 #endif
 829
 830 typedef struct type * (gdbarch_register_virtual_type_ftype) (int reg_nr);
 831 extern struct type * gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr);
 832 extern void set_gdbarch_register_virtual_type (struct gdbarch *gdbarch, gdbarch_register_virtual_type_ftype *register_virtual_type);
 833 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_VIRTUAL_TYPE)
 834 #error "Non multi-arch definition of REGISTER_VIRTUAL_TYPE"
 835 #endif
 836 #if GDB_MULTI_ARCH
 837 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_VIRTUAL_TYPE)
 838 #define REGISTER_VIRTUAL_TYPE(reg_nr) (gdbarch_register_virtual_type (current_gdbarch, reg_nr))
 839 #endif
 840 #endif
 841
 842 extern int gdbarch_register_type_p (struct gdbarch *gdbarch);
 843
 844 typedef struct type * (gdbarch_register_type_ftype) (struct gdbarch *gdbarch, int reg_nr);
 845 extern struct type * gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr);
 846 extern void set_gdbarch_register_type (struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type);
 847
 848 #if defined (DEPRECATED_DO_REGISTERS_INFO)
 849 /* Legacy for systems yet to multi-arch DEPRECATED_DO_REGISTERS_INFO */
 850 #if !defined (DEPRECATED_DO_REGISTERS_INFO_P)
 851 #define DEPRECATED_DO_REGISTERS_INFO_P() (1)
 852 #endif
 853 #endif
 854
 855 /* Default predicate for non- multi-arch targets. */
 856 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_DO_REGISTERS_INFO_P)
 857 #define DEPRECATED_DO_REGISTERS_INFO_P() (0)
 858 #endif
 859
 860 extern int gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch);
 861 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_DO_REGISTERS_INFO_P)
 862 #error "Non multi-arch definition of DEPRECATED_DO_REGISTERS_INFO"
 863 #endif
 864 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_DO_REGISTERS_INFO_P)
 865 #define DEPRECATED_DO_REGISTERS_INFO_P() (gdbarch_deprecated_do_registers_info_p (current_gdbarch))
 866 #endif
 867
 868 /* Default (function) for non- multi-arch platforms. */
 869 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_DO_REGISTERS_INFO)
 870 #define DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs) (internal_error (__FILE__, __LINE__, "DEPRECATED_DO_REGISTERS_INFO"), 0)
 871 #endif
 872
 873 typedef void (gdbarch_deprecated_do_registers_info_ftype) (int reg_nr, int fpregs);
 874 extern void gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs);
 875 extern void set_gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info);
 876 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_DO_REGISTERS_INFO)
 877 #error "Non multi-arch definition of DEPRECATED_DO_REGISTERS_INFO"
 878 #endif
 879 #if GDB_MULTI_ARCH
 880 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_DO_REGISTERS_INFO)
 881 #define DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs) (gdbarch_deprecated_do_registers_info (current_gdbarch, reg_nr, fpregs))
 882 #endif
 883 #endif
 884
 885 typedef void (gdbarch_print_registers_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
 886 extern void gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all);
 887 extern void set_gdbarch_print_registers_info (struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info);
 888
 889 extern int gdbarch_print_float_info_p (struct gdbarch *gdbarch);
 890
 891 typedef void (gdbarch_print_float_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 892 extern void gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 893 extern void set_gdbarch_print_float_info (struct gdbarch *gdbarch, gdbarch_print_float_info_ftype *print_float_info);
 894
 895 extern int gdbarch_print_vector_info_p (struct gdbarch *gdbarch);
 896
 897 typedef void (gdbarch_print_vector_info_ftype) (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 898 extern void gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args);
 899 extern void set_gdbarch_print_vector_info (struct gdbarch *gdbarch, gdbarch_print_vector_info_ftype *print_vector_info);
 900
 901 /* MAP a GDB RAW register number onto a simulator register number.  See
 902    also include/...-sim.h. */
 903
 904 /* Default (function) for non- multi-arch platforms. */
 905 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_SIM_REGNO)
 906 #define REGISTER_SIM_REGNO(reg_nr) (legacy_register_sim_regno (reg_nr))
 907 #endif
 908
 909 typedef int (gdbarch_register_sim_regno_ftype) (int reg_nr);
 910 extern int gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr);
 911 extern void set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno);
 912 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_SIM_REGNO)
 913 #error "Non multi-arch definition of REGISTER_SIM_REGNO"
 914 #endif
 915 #if GDB_MULTI_ARCH
 916 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_SIM_REGNO)
 917 #define REGISTER_SIM_REGNO(reg_nr) (gdbarch_register_sim_regno (current_gdbarch, reg_nr))
 918 #endif
 919 #endif
 920
 921 #if defined (REGISTER_BYTES_OK)
 922 /* Legacy for systems yet to multi-arch REGISTER_BYTES_OK */
 923 #if !defined (REGISTER_BYTES_OK_P)
 924 #define REGISTER_BYTES_OK_P() (1)
 925 #endif
 926 #endif
 927
 928 /* Default predicate for non- multi-arch targets. */
 929 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_BYTES_OK_P)
 930 #define REGISTER_BYTES_OK_P() (0)
 931 #endif
 932
 933 extern int gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch);
 934 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTES_OK_P)
 935 #error "Non multi-arch definition of REGISTER_BYTES_OK"
 936 #endif
 937 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTES_OK_P)
 938 #define REGISTER_BYTES_OK_P() (gdbarch_register_bytes_ok_p (current_gdbarch))
 939 #endif
 940
 941 /* Default (function) for non- multi-arch platforms. */
 942 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_BYTES_OK)
 943 #define REGISTER_BYTES_OK(nr_bytes) (internal_error (__FILE__, __LINE__, "REGISTER_BYTES_OK"), 0)
 944 #endif
 945
 946 typedef int (gdbarch_register_bytes_ok_ftype) (long nr_bytes);
 947 extern int gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes);
 948 extern void set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch, gdbarch_register_bytes_ok_ftype *register_bytes_ok);
 949 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTES_OK)
 950 #error "Non multi-arch definition of REGISTER_BYTES_OK"
 951 #endif
 952 #if GDB_MULTI_ARCH
 953 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTES_OK)
 954 #define REGISTER_BYTES_OK(nr_bytes) (gdbarch_register_bytes_ok (current_gdbarch, nr_bytes))
 955 #endif
 956 #endif
 957
 958 /* Default (function) for non- multi-arch platforms. */
 959 #if (!GDB_MULTI_ARCH) && !defined (CANNOT_FETCH_REGISTER)
 960 #define CANNOT_FETCH_REGISTER(regnum) (cannot_register_not (regnum))
 961 #endif
 962
 963 typedef int (gdbarch_cannot_fetch_register_ftype) (int regnum);
 964 extern int gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum);
 965 extern void set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register);
 966 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CANNOT_FETCH_REGISTER)
 967 #error "Non multi-arch definition of CANNOT_FETCH_REGISTER"
 968 #endif
 969 #if GDB_MULTI_ARCH
 970 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CANNOT_FETCH_REGISTER)
 971 #define CANNOT_FETCH_REGISTER(regnum) (gdbarch_cannot_fetch_register (current_gdbarch, regnum))
 972 #endif
 973 #endif
 974
 975 /* Default (function) for non- multi-arch platforms. */
 976 #if (!GDB_MULTI_ARCH) && !defined (CANNOT_STORE_REGISTER)
 977 #define CANNOT_STORE_REGISTER(regnum) (cannot_register_not (regnum))
 978 #endif
 979
 980 typedef int (gdbarch_cannot_store_register_ftype) (int regnum);
 981 extern int gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum);
 982 extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register);
 983 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CANNOT_STORE_REGISTER)
 984 #error "Non multi-arch definition of CANNOT_STORE_REGISTER"
 985 #endif
 986 #if GDB_MULTI_ARCH
 987 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CANNOT_STORE_REGISTER)
 988 #define CANNOT_STORE_REGISTER(regnum) (gdbarch_cannot_store_register (current_gdbarch, regnum))
 989 #endif
 990 #endif
 991
 992 /* setjmp/longjmp support. */
 993
 994 #if defined (GET_LONGJMP_TARGET)
 995 /* Legacy for systems yet to multi-arch GET_LONGJMP_TARGET */
 996 #if !defined (GET_LONGJMP_TARGET_P)
 997 #define GET_LONGJMP_TARGET_P() (1)
 998 #endif
 999 #endif
1000
1001 /* Default predicate for non- multi-arch targets. */
1002 #if (!GDB_MULTI_ARCH) && !defined (GET_LONGJMP_TARGET_P)
1003 #define GET_LONGJMP_TARGET_P() (0)
1004 #endif
1005
1006 extern int gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
1007 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (GET_LONGJMP_TARGET_P)
1008 #error "Non multi-arch definition of GET_LONGJMP_TARGET"
1009 #endif
1010 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (GET_LONGJMP_TARGET_P)
1011 #define GET_LONGJMP_TARGET_P() (gdbarch_get_longjmp_target_p (current_gdbarch))
1012 #endif
1013
1014 /* Default (function) for non- multi-arch platforms. */
1015 #if (!GDB_MULTI_ARCH) && !defined (GET_LONGJMP_TARGET)
1016 #define GET_LONGJMP_TARGET(pc) (internal_error (__FILE__, __LINE__, "GET_LONGJMP_TARGET"), 0)
1017 #endif
1018
1019 typedef int (gdbarch_get_longjmp_target_ftype) (CORE_ADDR *pc);
1020 extern int gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc);
1021 extern void set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target);
1022 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (GET_LONGJMP_TARGET)
1023 #error "Non multi-arch definition of GET_LONGJMP_TARGET"
1024 #endif
1025 #if GDB_MULTI_ARCH
1026 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (GET_LONGJMP_TARGET)
1027 #define GET_LONGJMP_TARGET(pc) (gdbarch_get_longjmp_target (current_gdbarch, pc))
1028 #endif
1029 #endif
1030
1031 /* Non multi-arch DUMMY_FRAMES are a mess (multi-arch ones are not that
1032    much better but at least they are vaguely consistent).  The headers
1033    and body contain convoluted #if/#else sequences for determine how
1034    things should be compiled.  Instead of trying to mimic that
1035    behaviour here (and hence entrench it further) gdbarch simply
1036    reqires that these methods be set up from the word go.  This also
1037    avoids any potential problems with moving beyond multi-arch partial. */
1038
1039 /* Default (value) for non- multi-arch platforms. */
1040 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1041 #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES (1)
1042 #endif
1043
1044 extern int gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch);
1045 extern void set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch, int deprecated_use_generic_dummy_frames);
1046 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1047 #error "Non multi-arch definition of DEPRECATED_USE_GENERIC_DUMMY_FRAMES"
1048 #endif
1049 #if GDB_MULTI_ARCH
1050 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1051 #define DEPRECATED_USE_GENERIC_DUMMY_FRAMES (gdbarch_deprecated_use_generic_dummy_frames (current_gdbarch))
1052 #endif
1053 #endif
1054
1055 /* Default (value) for non- multi-arch platforms. */
1056 #if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_LOCATION)
1057 #define CALL_DUMMY_LOCATION (AT_ENTRY_POINT)
1058 #endif
1059
1060 extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
1061 extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
1062 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_LOCATION)
1063 #error "Non multi-arch definition of CALL_DUMMY_LOCATION"
1064 #endif
1065 #if GDB_MULTI_ARCH
1066 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_LOCATION)
1067 #define CALL_DUMMY_LOCATION (gdbarch_call_dummy_location (current_gdbarch))
1068 #endif
1069 #endif
1070
1071 typedef CORE_ADDR (gdbarch_call_dummy_address_ftype) (void);
1072 extern CORE_ADDR gdbarch_call_dummy_address (struct gdbarch *gdbarch);
1073 extern void set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, gdbarch_call_dummy_address_ftype *call_dummy_address);
1074 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_ADDRESS)
1075 #error "Non multi-arch definition of CALL_DUMMY_ADDRESS"
1076 #endif
1077 #if GDB_MULTI_ARCH
1078 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_ADDRESS)
1079 #define CALL_DUMMY_ADDRESS() (gdbarch_call_dummy_address (current_gdbarch))
1080 #endif
1081 #endif
1082
1083 extern CORE_ADDR gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch);
1084 extern void set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_start_offset);
1085 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_START_OFFSET)
1086 #error "Non multi-arch definition of CALL_DUMMY_START_OFFSET"
1087 #endif
1088 #if GDB_MULTI_ARCH
1089 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_START_OFFSET)
1090 #define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
1091 #endif
1092 #endif
1093
1094 extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
1095 extern void set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_breakpoint_offset);
1096 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_BREAKPOINT_OFFSET)
1097 #error "Non multi-arch definition of CALL_DUMMY_BREAKPOINT_OFFSET"
1098 #endif
1099 #if GDB_MULTI_ARCH
1100 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
1101 #define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
1102 #endif
1103 #endif
1104
1105 extern int gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch);
1106 extern void set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch, int call_dummy_breakpoint_offset_p);
1107 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_BREAKPOINT_OFFSET_P)
1108 #error "Non multi-arch definition of CALL_DUMMY_BREAKPOINT_OFFSET_P"
1109 #endif
1110 #if GDB_MULTI_ARCH
1111 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET_P)
1112 #define CALL_DUMMY_BREAKPOINT_OFFSET_P (gdbarch_call_dummy_breakpoint_offset_p (current_gdbarch))
1113 #endif
1114 #endif
1115
1116 extern int gdbarch_call_dummy_length (struct gdbarch *gdbarch);
1117 extern void set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, int call_dummy_length);
1118 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_LENGTH)
1119 #error "Non multi-arch definition of CALL_DUMMY_LENGTH"
1120 #endif
1121 #if GDB_MULTI_ARCH
1122 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_LENGTH)
1123 #define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
1124 #endif
1125 #endif
1126
1127 /* NOTE: cagney/2002-11-24: This function with predicate has a valid
1128    (callable) initial value.  As a consequence, even when the predicate
1129    is false, the corresponding function works.  This simplifies the
1130    migration process - old code, calling DEPRECATED_PC_IN_CALL_DUMMY(),
1131    doesn't need to be modified. */
1132
1133 #if defined (DEPRECATED_PC_IN_CALL_DUMMY)
1134 /* Legacy for systems yet to multi-arch DEPRECATED_PC_IN_CALL_DUMMY */
1135 #if !defined (DEPRECATED_PC_IN_CALL_DUMMY_P)
1136 #define DEPRECATED_PC_IN_CALL_DUMMY_P() (1)
1137 #endif
1138 #endif
1139
1140 /* Default predicate for non- multi-arch targets. */
1141 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_PC_IN_CALL_DUMMY_P)
1142 #define DEPRECATED_PC_IN_CALL_DUMMY_P() (0)
1143 #endif
1144
1145 extern int gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch *gdbarch);
1146 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_PC_IN_CALL_DUMMY_P)
1147 #error "Non multi-arch definition of DEPRECATED_PC_IN_CALL_DUMMY"
1148 #endif
1149 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_PC_IN_CALL_DUMMY_P)
1150 #define DEPRECATED_PC_IN_CALL_DUMMY_P() (gdbarch_deprecated_pc_in_call_dummy_p (current_gdbarch))
1151 #endif
1152
1153 /* Default (function) for non- multi-arch platforms. */
1154 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_PC_IN_CALL_DUMMY)
1155 #define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) (generic_pc_in_call_dummy (pc, sp, frame_address))
1156 #endif
1157
1158 typedef int (gdbarch_deprecated_pc_in_call_dummy_ftype) (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address);
1159 extern int gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address);
1160 extern void set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_pc_in_call_dummy);
1161 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_PC_IN_CALL_DUMMY)
1162 #error "Non multi-arch definition of DEPRECATED_PC_IN_CALL_DUMMY"
1163 #endif
1164 #if GDB_MULTI_ARCH
1165 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_PC_IN_CALL_DUMMY)
1166 #define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) (gdbarch_deprecated_pc_in_call_dummy (current_gdbarch, pc, sp, frame_address))
1167 #endif
1168 #endif
1169
1170 extern int gdbarch_call_dummy_p (struct gdbarch *gdbarch);
1171 extern void set_gdbarch_call_dummy_p (struct gdbarch *gdbarch, int call_dummy_p);
1172 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_P)
1173 #error "Non multi-arch definition of CALL_DUMMY_P"
1174 #endif
1175 #if GDB_MULTI_ARCH
1176 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_P)
1177 #define CALL_DUMMY_P (gdbarch_call_dummy_p (current_gdbarch))
1178 #endif
1179 #endif
1180
1181 /* Default (value) for non- multi-arch platforms. */
1182 #if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_WORDS)
1183 #define CALL_DUMMY_WORDS (legacy_call_dummy_words)
1184 #endif
1185
1186 extern LONGEST * gdbarch_call_dummy_words (struct gdbarch *gdbarch);
1187 extern void set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, LONGEST * call_dummy_words);
1188 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_WORDS)
1189 #error "Non multi-arch definition of CALL_DUMMY_WORDS"
1190 #endif
1191 #if GDB_MULTI_ARCH
1192 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_WORDS)
1193 #define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
1194 #endif
1195 #endif
1196
1197 /* Default (value) for non- multi-arch platforms. */
1198 #if (!GDB_MULTI_ARCH) && !defined (SIZEOF_CALL_DUMMY_WORDS)
1199 #define SIZEOF_CALL_DUMMY_WORDS (legacy_sizeof_call_dummy_words)
1200 #endif
1201
1202 extern int gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch);
1203 extern void set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, int sizeof_call_dummy_words);
1204 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIZEOF_CALL_DUMMY_WORDS)
1205 #error "Non multi-arch definition of SIZEOF_CALL_DUMMY_WORDS"
1206 #endif
1207 #if GDB_MULTI_ARCH
1208 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SIZEOF_CALL_DUMMY_WORDS)
1209 #define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
1210 #endif
1211 #endif
1212
1213 extern int gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch);
1214 extern void set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch, int call_dummy_stack_adjust_p);
1215 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_STACK_ADJUST_P)
1216 #error "Non multi-arch definition of CALL_DUMMY_STACK_ADJUST_P"
1217 #endif
1218 #if GDB_MULTI_ARCH
1219 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_STACK_ADJUST_P)
1220 #define CALL_DUMMY_STACK_ADJUST_P (gdbarch_call_dummy_stack_adjust_p (current_gdbarch))
1221 #endif
1222 #endif
1223
1224 extern int gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch);
1225 extern void set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch, int call_dummy_stack_adjust);
1226 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_STACK_ADJUST)
1227 #error "Non multi-arch definition of CALL_DUMMY_STACK_ADJUST"
1228 #endif
1229 #if GDB_MULTI_ARCH
1230 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_STACK_ADJUST)
1231 #define CALL_DUMMY_STACK_ADJUST (gdbarch_call_dummy_stack_adjust (current_gdbarch))
1232 #endif
1233 #endif
1234
1235 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);
1236 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);
1237 extern void set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_fix_call_dummy_ftype *fix_call_dummy);
1238 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FIX_CALL_DUMMY)
1239 #error "Non multi-arch definition of FIX_CALL_DUMMY"
1240 #endif
1241 #if GDB_MULTI_ARCH
1242 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FIX_CALL_DUMMY)
1243 #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))
1244 #endif
1245 #endif
1246
1247 #if defined (DEPRECATED_INIT_FRAME_PC_FIRST)
1248 /* Legacy for systems yet to multi-arch DEPRECATED_INIT_FRAME_PC_FIRST */
1249 #if !defined (DEPRECATED_INIT_FRAME_PC_FIRST_P)
1250 #define DEPRECATED_INIT_FRAME_PC_FIRST_P() (1)
1251 #endif
1252 #endif
1253
1254 /* Default predicate for non- multi-arch targets. */
1255 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_INIT_FRAME_PC_FIRST_P)
1256 #define DEPRECATED_INIT_FRAME_PC_FIRST_P() (0)
1257 #endif
1258
1259 extern int gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch);
1260 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_INIT_FRAME_PC_FIRST_P)
1261 #error "Non multi-arch definition of DEPRECATED_INIT_FRAME_PC_FIRST"
1262 #endif
1263 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_INIT_FRAME_PC_FIRST_P)
1264 #define DEPRECATED_INIT_FRAME_PC_FIRST_P() (gdbarch_deprecated_init_frame_pc_first_p (current_gdbarch))
1265 #endif
1266
1267 /* Default (function) for non- multi-arch platforms. */
1268 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_INIT_FRAME_PC_FIRST)
1269 #define DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev) (internal_error (__FILE__, __LINE__, "DEPRECATED_INIT_FRAME_PC_FIRST"), 0)
1270 #endif
1271
1272 typedef CORE_ADDR (gdbarch_deprecated_init_frame_pc_first_ftype) (int fromleaf, struct frame_info *prev);
1273 extern CORE_ADDR gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev);
1274 extern void set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first);
1275 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_INIT_FRAME_PC_FIRST)
1276 #error "Non multi-arch definition of DEPRECATED_INIT_FRAME_PC_FIRST"
1277 #endif
1278 #if GDB_MULTI_ARCH
1279 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_INIT_FRAME_PC_FIRST)
1280 #define DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev) (gdbarch_deprecated_init_frame_pc_first (current_gdbarch, fromleaf, prev))
1281 #endif
1282 #endif
1283
1284 #if defined (DEPRECATED_INIT_FRAME_PC)
1285 /* Legacy for systems yet to multi-arch DEPRECATED_INIT_FRAME_PC */
1286 #if !defined (DEPRECATED_INIT_FRAME_PC_P)
1287 #define DEPRECATED_INIT_FRAME_PC_P() (1)
1288 #endif
1289 #endif
1290
1291 /* Default predicate for non- multi-arch targets. */
1292 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_INIT_FRAME_PC_P)
1293 #define DEPRECATED_INIT_FRAME_PC_P() (0)
1294 #endif
1295
1296 extern int gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch);
1297 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_INIT_FRAME_PC_P)
1298 #error "Non multi-arch definition of DEPRECATED_INIT_FRAME_PC"
1299 #endif
1300 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_INIT_FRAME_PC_P)
1301 #define DEPRECATED_INIT_FRAME_PC_P() (gdbarch_deprecated_init_frame_pc_p (current_gdbarch))
1302 #endif
1303
1304 /* Default (function) for non- multi-arch platforms. */
1305 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_INIT_FRAME_PC)
1306 #define DEPRECATED_INIT_FRAME_PC(fromleaf, prev) (internal_error (__FILE__, __LINE__, "DEPRECATED_INIT_FRAME_PC"), 0)
1307 #endif
1308
1309 typedef CORE_ADDR (gdbarch_deprecated_init_frame_pc_ftype) (int fromleaf, struct frame_info *prev);
1310 extern CORE_ADDR gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev);
1311 extern void set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc);
1312 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_INIT_FRAME_PC)
1313 #error "Non multi-arch definition of DEPRECATED_INIT_FRAME_PC"
1314 #endif
1315 #if GDB_MULTI_ARCH
1316 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_INIT_FRAME_PC)
1317 #define DEPRECATED_INIT_FRAME_PC(fromleaf, prev) (gdbarch_deprecated_init_frame_pc (current_gdbarch, fromleaf, prev))
1318 #endif
1319 #endif
1320
1321 extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
1322 extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
1323 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (BELIEVE_PCC_PROMOTION)
1324 #error "Non multi-arch definition of BELIEVE_PCC_PROMOTION"
1325 #endif
1326 #if GDB_MULTI_ARCH
1327 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (BELIEVE_PCC_PROMOTION)
1328 #define BELIEVE_PCC_PROMOTION (gdbarch_believe_pcc_promotion (current_gdbarch))
1329 #endif
1330 #endif
1331
1332 extern int gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch);
1333 extern void set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch, int believe_pcc_promotion_type);
1334 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (BELIEVE_PCC_PROMOTION_TYPE)
1335 #error "Non multi-arch definition of BELIEVE_PCC_PROMOTION_TYPE"
1336 #endif
1337 #if !defined (BELIEVE_PCC_PROMOTION_TYPE)
1338 #define BELIEVE_PCC_PROMOTION_TYPE (gdbarch_believe_pcc_promotion_type (current_gdbarch))
1339 #endif
1340
1341 #if defined (GET_SAVED_REGISTER)
1342 /* Legacy for systems yet to multi-arch GET_SAVED_REGISTER */
1343 #if !defined (GET_SAVED_REGISTER_P)
1344 #define GET_SAVED_REGISTER_P() (1)
1345 #endif
1346 #endif
1347
1348 /* Default predicate for non- multi-arch targets. */
1349 #if (!GDB_MULTI_ARCH) && !defined (GET_SAVED_REGISTER_P)
1350 #define GET_SAVED_REGISTER_P() (0)
1351 #endif
1352
1353 extern int gdbarch_get_saved_register_p (struct gdbarch *gdbarch);
1354 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (GET_SAVED_REGISTER_P)
1355 #error "Non multi-arch definition of GET_SAVED_REGISTER"
1356 #endif
1357 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (GET_SAVED_REGISTER_P)
1358 #define GET_SAVED_REGISTER_P() (gdbarch_get_saved_register_p (current_gdbarch))
1359 #endif
1360
1361 /* Default (function) for non- multi-arch platforms. */
1362 #if (!GDB_MULTI_ARCH) && !defined (GET_SAVED_REGISTER)
1363 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) (internal_error (__FILE__, __LINE__, "GET_SAVED_REGISTER"), 0)
1364 #endif
1365
1366 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);
1367 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);
1368 extern void set_gdbarch_get_saved_register (struct gdbarch *gdbarch, gdbarch_get_saved_register_ftype *get_saved_register);
1369 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (GET_SAVED_REGISTER)
1370 #error "Non multi-arch definition of GET_SAVED_REGISTER"
1371 #endif
1372 #if GDB_MULTI_ARCH
1373 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (GET_SAVED_REGISTER)
1374 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) (gdbarch_get_saved_register (current_gdbarch, raw_buffer, optimized, addrp, frame, regnum, lval))
1375 #endif
1376 #endif
1377
1378 /* Default (function) for non- multi-arch platforms. */
1379 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_CONVERTIBLE)
1380 #define REGISTER_CONVERTIBLE(nr) (generic_register_convertible_not (nr))
1381 #endif
1382
1383 typedef int (gdbarch_register_convertible_ftype) (int nr);
1384 extern int gdbarch_register_convertible (struct gdbarch *gdbarch, int nr);
1385 extern void set_gdbarch_register_convertible (struct gdbarch *gdbarch, gdbarch_register_convertible_ftype *register_convertible);
1386 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_CONVERTIBLE)
1387 #error "Non multi-arch definition of REGISTER_CONVERTIBLE"
1388 #endif
1389 #if GDB_MULTI_ARCH
1390 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_CONVERTIBLE)
1391 #define REGISTER_CONVERTIBLE(nr) (gdbarch_register_convertible (current_gdbarch, nr))
1392 #endif
1393 #endif
1394
1395 /* Default (function) for non- multi-arch platforms. */
1396 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_CONVERT_TO_VIRTUAL)
1397 #define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (internal_error (__FILE__, __LINE__, "REGISTER_CONVERT_TO_VIRTUAL"), 0)
1398 #endif
1399
1400 typedef void (gdbarch_register_convert_to_virtual_ftype) (int regnum, struct type *type, char *from, char *to);
1401 extern void gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to);
1402 extern void set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual);
1403 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_CONVERT_TO_VIRTUAL)
1404 #error "Non multi-arch definition of REGISTER_CONVERT_TO_VIRTUAL"
1405 #endif
1406 #if GDB_MULTI_ARCH
1407 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_CONVERT_TO_VIRTUAL)
1408 #define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (gdbarch_register_convert_to_virtual (current_gdbarch, regnum, type, from, to))
1409 #endif
1410 #endif
1411
1412 /* Default (function) for non- multi-arch platforms. */
1413 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_CONVERT_TO_RAW)
1414 #define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (internal_error (__FILE__, __LINE__, "REGISTER_CONVERT_TO_RAW"), 0)
1415 #endif
1416
1417 typedef void (gdbarch_register_convert_to_raw_ftype) (struct type *type, int regnum, char *from, char *to);
1418 extern void gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to);
1419 extern void set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, gdbarch_register_convert_to_raw_ftype *register_convert_to_raw);
1420 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_CONVERT_TO_RAW)
1421 #error "Non multi-arch definition of REGISTER_CONVERT_TO_RAW"
1422 #endif
1423 #if GDB_MULTI_ARCH
1424 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_CONVERT_TO_RAW)
1425 #define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (gdbarch_register_convert_to_raw (current_gdbarch, type, regnum, from, to))
1426 #endif
1427 #endif
1428
1429 /* Default (function) for non- multi-arch platforms. */
1430 #if (!GDB_MULTI_ARCH) && !defined (CONVERT_REGISTER_P)
1431 #define CONVERT_REGISTER_P(regnum) (legacy_convert_register_p (regnum))
1432 #endif
1433
1434 typedef int (gdbarch_convert_register_p_ftype) (int regnum);
1435 extern int gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum);
1436 extern void set_gdbarch_convert_register_p (struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p);
1437 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (CONVERT_REGISTER_P)
1438 #error "Non multi-arch definition of CONVERT_REGISTER_P"
1439 #endif
1440 #if GDB_MULTI_ARCH
1441 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (CONVERT_REGISTER_P)
1442 #define CONVERT_REGISTER_P(regnum) (gdbarch_convert_register_p (current_gdbarch, regnum))
1443 #endif
1444 #endif
1445
1446 /* Default (function) for non- multi-arch platforms. */
1447 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_TO_VALUE)
1448 #define REGISTER_TO_VALUE(regnum, type, from, to) (legacy_register_to_value (regnum, type, from, to))
1449 #endif
1450
1451 typedef void (gdbarch_register_to_value_ftype) (int regnum, struct type *type, char *from, char *to);
1452 extern void gdbarch_register_to_value (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to);
1453 extern void set_gdbarch_register_to_value (struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value);
1454 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_TO_VALUE)
1455 #error "Non multi-arch definition of REGISTER_TO_VALUE"
1456 #endif
1457 #if GDB_MULTI_ARCH
1458 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_TO_VALUE)
1459 #define REGISTER_TO_VALUE(regnum, type, from, to) (gdbarch_register_to_value (current_gdbarch, regnum, type, from, to))
1460 #endif
1461 #endif
1462
1463 /* Default (function) for non- multi-arch platforms. */
1464 #if (!GDB_MULTI_ARCH) && !defined (VALUE_TO_REGISTER)
1465 #define VALUE_TO_REGISTER(type, regnum, from, to) (legacy_value_to_register (type, regnum, from, to))
1466 #endif
1467
1468 typedef void (gdbarch_value_to_register_ftype) (struct type *type, int regnum, char *from, char *to);
1469 extern void gdbarch_value_to_register (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to);
1470 extern void set_gdbarch_value_to_register (struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register);
1471 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (VALUE_TO_REGISTER)
1472 #error "Non multi-arch definition of VALUE_TO_REGISTER"
1473 #endif
1474 #if GDB_MULTI_ARCH
1475 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (VALUE_TO_REGISTER)
1476 #define VALUE_TO_REGISTER(type, regnum, from, to) (gdbarch_value_to_register (current_gdbarch, type, regnum, from, to))
1477 #endif
1478 #endif
1479
1480 /* Default (function) for non- multi-arch platforms. */
1481 #if (!GDB_MULTI_ARCH) && !defined (POINTER_TO_ADDRESS)
1482 #define POINTER_TO_ADDRESS(type, buf) (unsigned_pointer_to_address (type, buf))
1483 #endif
1484
1485 typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct type *type, const void *buf);
1486 extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf);
1487 extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address);
1488 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (POINTER_TO_ADDRESS)
1489 #error "Non multi-arch definition of POINTER_TO_ADDRESS"
1490 #endif
1491 #if GDB_MULTI_ARCH
1492 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (POINTER_TO_ADDRESS)
1493 #define POINTER_TO_ADDRESS(type, buf) (gdbarch_pointer_to_address (current_gdbarch, type, buf))
1494 #endif
1495 #endif
1496
1497 /* Default (function) for non- multi-arch platforms. */
1498 #if (!GDB_MULTI_ARCH) && !defined (ADDRESS_TO_POINTER)
1499 #define ADDRESS_TO_POINTER(type, buf, addr) (unsigned_address_to_pointer (type, buf, addr))
1500 #endif
1501
1502 typedef void (gdbarch_address_to_pointer_ftype) (struct type *type, void *buf, CORE_ADDR addr);
1503 extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr);
1504 extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer);
1505 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (ADDRESS_TO_POINTER)
1506 #error "Non multi-arch definition of ADDRESS_TO_POINTER"
1507 #endif
1508 #if GDB_MULTI_ARCH
1509 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ADDRESS_TO_POINTER)
1510 #define ADDRESS_TO_POINTER(type, buf, addr) (gdbarch_address_to_pointer (current_gdbarch, type, buf, addr))
1511 #endif
1512 #endif
1513
1514 #if defined (INTEGER_TO_ADDRESS)
1515 /* Legacy for systems yet to multi-arch INTEGER_TO_ADDRESS */
1516 #if !defined (INTEGER_TO_ADDRESS_P)
1517 #define INTEGER_TO_ADDRESS_P() (1)
1518 #endif
1519 #endif
1520
1521 /* Default predicate for non- multi-arch targets. */
1522 #if (!GDB_MULTI_ARCH) && !defined (INTEGER_TO_ADDRESS_P)
1523 #define INTEGER_TO_ADDRESS_P() (0)
1524 #endif
1525
1526 extern int gdbarch_integer_to_address_p (struct gdbarch *gdbarch);
1527 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (INTEGER_TO_ADDRESS_P)
1528 #error "Non multi-arch definition of INTEGER_TO_ADDRESS"
1529 #endif
1530 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (INTEGER_TO_ADDRESS_P)
1531 #define INTEGER_TO_ADDRESS_P() (gdbarch_integer_to_address_p (current_gdbarch))
1532 #endif
1533
1534 /* Default (function) for non- multi-arch platforms. */
1535 #if (!GDB_MULTI_ARCH) && !defined (INTEGER_TO_ADDRESS)
1536 #define INTEGER_TO_ADDRESS(type, buf) (internal_error (__FILE__, __LINE__, "INTEGER_TO_ADDRESS"), 0)
1537 #endif
1538
1539 typedef CORE_ADDR (gdbarch_integer_to_address_ftype) (struct type *type, void *buf);
1540 extern CORE_ADDR gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf);
1541 extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address);
1542 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (INTEGER_TO_ADDRESS)
1543 #error "Non multi-arch definition of INTEGER_TO_ADDRESS"
1544 #endif
1545 #if GDB_MULTI_ARCH
1546 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (INTEGER_TO_ADDRESS)
1547 #define INTEGER_TO_ADDRESS(type, buf) (gdbarch_integer_to_address (current_gdbarch, type, buf))
1548 #endif
1549 #endif
1550
1551 /* Default (function) for non- multi-arch platforms. */
1552 #if (!GDB_MULTI_ARCH) && !defined (RETURN_VALUE_ON_STACK)
1553 #define RETURN_VALUE_ON_STACK(type) (generic_return_value_on_stack_not (type))
1554 #endif
1555
1556 typedef int (gdbarch_return_value_on_stack_ftype) (struct type *type);
1557 extern int gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type);
1558 extern void set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch, gdbarch_return_value_on_stack_ftype *return_value_on_stack);
1559 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (RETURN_VALUE_ON_STACK)
1560 #error "Non multi-arch definition of RETURN_VALUE_ON_STACK"
1561 #endif
1562 #if GDB_MULTI_ARCH
1563 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (RETURN_VALUE_ON_STACK)
1564 #define RETURN_VALUE_ON_STACK(type) (gdbarch_return_value_on_stack (current_gdbarch, type))
1565 #endif
1566 #endif
1567
1568 /* Default (function) for non- multi-arch platforms. */
1569 #if (!GDB_MULTI_ARCH) && !defined (PUSH_ARGUMENTS)
1570 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) (default_push_arguments (nargs, args, sp, struct_return, struct_addr))
1571 #endif
1572
1573 typedef CORE_ADDR (gdbarch_push_arguments_ftype) (int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
1574 extern CORE_ADDR gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
1575 extern void set_gdbarch_push_arguments (struct gdbarch *gdbarch, gdbarch_push_arguments_ftype *push_arguments);
1576 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PUSH_ARGUMENTS)
1577 #error "Non multi-arch definition of PUSH_ARGUMENTS"
1578 #endif
1579 #if GDB_MULTI_ARCH
1580 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PUSH_ARGUMENTS)
1581 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) (gdbarch_push_arguments (current_gdbarch, nargs, args, sp, struct_return, struct_addr))
1582 #endif
1583 #endif
1584
1585 #if defined (DEPRECATED_PUSH_DUMMY_FRAME)
1586 /* Legacy for systems yet to multi-arch DEPRECATED_PUSH_DUMMY_FRAME */
1587 #if !defined (DEPRECATED_PUSH_DUMMY_FRAME_P)
1588 #define DEPRECATED_PUSH_DUMMY_FRAME_P() (1)
1589 #endif
1590 #endif
1591
1592 /* Default predicate for non- multi-arch targets. */
1593 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_PUSH_DUMMY_FRAME_P)
1594 #define DEPRECATED_PUSH_DUMMY_FRAME_P() (0)
1595 #endif
1596
1597 extern int gdbarch_deprecated_push_dummy_frame_p (struct gdbarch *gdbarch);
1598 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_PUSH_DUMMY_FRAME_P)
1599 #error "Non multi-arch definition of DEPRECATED_PUSH_DUMMY_FRAME"
1600 #endif
1601 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_PUSH_DUMMY_FRAME_P)
1602 #define DEPRECATED_PUSH_DUMMY_FRAME_P() (gdbarch_deprecated_push_dummy_frame_p (current_gdbarch))
1603 #endif
1604
1605 /* Default (function) for non- multi-arch platforms. */
1606 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_PUSH_DUMMY_FRAME)
1607 #define DEPRECATED_PUSH_DUMMY_FRAME (internal_error (__FILE__, __LINE__, "DEPRECATED_PUSH_DUMMY_FRAME"), 0)
1608 #define DEPRECATED_PUSH_DUMMY_FRAME (gdbarch_deprecated_push_dummy_frame (current_gdbarch))
1609 #endif
1610
1611 typedef void (gdbarch_deprecated_push_dummy_frame_ftype) (void);
1612 extern void gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch);
1613 extern void set_gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch, gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame);
1614 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_PUSH_DUMMY_FRAME)
1615 #error "Non multi-arch definition of DEPRECATED_PUSH_DUMMY_FRAME"
1616 #endif
1617 #if GDB_MULTI_ARCH
1618 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_PUSH_DUMMY_FRAME)
1619 #define DEPRECATED_PUSH_DUMMY_FRAME (gdbarch_deprecated_push_dummy_frame (current_gdbarch))
1620 #endif
1621 #endif
1622
1623 #if defined (PUSH_RETURN_ADDRESS)
1624 /* Legacy for systems yet to multi-arch PUSH_RETURN_ADDRESS */
1625 #if !defined (PUSH_RETURN_ADDRESS_P)
1626 #define PUSH_RETURN_ADDRESS_P() (1)
1627 #endif
1628 #endif
1629
1630 /* Default predicate for non- multi-arch targets. */
1631 #if (!GDB_MULTI_ARCH) && !defined (PUSH_RETURN_ADDRESS_P)
1632 #define PUSH_RETURN_ADDRESS_P() (0)
1633 #endif
1634
1635 extern int gdbarch_push_return_address_p (struct gdbarch *gdbarch);
1636 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PUSH_RETURN_ADDRESS_P)
1637 #error "Non multi-arch definition of PUSH_RETURN_ADDRESS"
1638 #endif
1639 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PUSH_RETURN_ADDRESS_P)
1640 #define PUSH_RETURN_ADDRESS_P() (gdbarch_push_return_address_p (current_gdbarch))
1641 #endif
1642
1643 /* Default (function) for non- multi-arch platforms. */
1644 #if (!GDB_MULTI_ARCH) && !defined (PUSH_RETURN_ADDRESS)
1645 #define PUSH_RETURN_ADDRESS(pc, sp) (internal_error (__FILE__, __LINE__, "PUSH_RETURN_ADDRESS"), 0)
1646 #endif
1647
1648 typedef CORE_ADDR (gdbarch_push_return_address_ftype) (CORE_ADDR pc, CORE_ADDR sp);
1649 extern CORE_ADDR gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp);
1650 extern void set_gdbarch_push_return_address (struct gdbarch *gdbarch, gdbarch_push_return_address_ftype *push_return_address);
1651 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PUSH_RETURN_ADDRESS)
1652 #error "Non multi-arch definition of PUSH_RETURN_ADDRESS"
1653 #endif
1654 #if GDB_MULTI_ARCH
1655 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PUSH_RETURN_ADDRESS)
1656 #define PUSH_RETURN_ADDRESS(pc, sp) (gdbarch_push_return_address (current_gdbarch, pc, sp))
1657 #endif
1658 #endif
1659
1660 #if defined (POP_FRAME)
1661 /* Legacy for systems yet to multi-arch POP_FRAME */
1662 #if !defined (POP_FRAME_P)
1663 #define POP_FRAME_P() (1)
1664 #endif
1665 #endif
1666
1667 /* Default predicate for non- multi-arch targets. */
1668 #if (!GDB_MULTI_ARCH) && !defined (POP_FRAME_P)
1669 #define POP_FRAME_P() (0)
1670 #endif
1671
1672 extern int gdbarch_pop_frame_p (struct gdbarch *gdbarch);
1673 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (POP_FRAME_P)
1674 #error "Non multi-arch definition of POP_FRAME"
1675 #endif
1676 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (POP_FRAME_P)
1677 #define POP_FRAME_P() (gdbarch_pop_frame_p (current_gdbarch))
1678 #endif
1679
1680 /* Default (function) for non- multi-arch platforms. */
1681 #if (!GDB_MULTI_ARCH) && !defined (POP_FRAME)
1682 #define POP_FRAME (internal_error (__FILE__, __LINE__, "POP_FRAME"), 0)
1683 #define POP_FRAME (gdbarch_pop_frame (current_gdbarch))
1684 #endif
1685
1686 typedef void (gdbarch_pop_frame_ftype) (void);
1687 extern void gdbarch_pop_frame (struct gdbarch *gdbarch);
1688 extern void set_gdbarch_pop_frame (struct gdbarch *gdbarch, gdbarch_pop_frame_ftype *pop_frame);
1689 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (POP_FRAME)
1690 #error "Non multi-arch definition of POP_FRAME"
1691 #endif
1692 #if GDB_MULTI_ARCH
1693 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (POP_FRAME)
1694 #define POP_FRAME (gdbarch_pop_frame (current_gdbarch))
1695 #endif
1696 #endif
1697
1698 typedef void (gdbarch_store_struct_return_ftype) (CORE_ADDR addr, CORE_ADDR sp);
1699 extern void gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp);
1700 extern void set_gdbarch_store_struct_return (struct gdbarch *gdbarch, gdbarch_store_struct_return_ftype *store_struct_return);
1701 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STORE_STRUCT_RETURN)
1702 #error "Non multi-arch definition of STORE_STRUCT_RETURN"
1703 #endif
1704 #if GDB_MULTI_ARCH
1705 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STORE_STRUCT_RETURN)
1706 #define STORE_STRUCT_RETURN(addr, sp) (gdbarch_store_struct_return (current_gdbarch, addr, sp))
1707 #endif
1708 #endif
1709
1710 /* Default (function) for non- multi-arch platforms. */
1711 #if (!GDB_MULTI_ARCH) && !defined (EXTRACT_RETURN_VALUE)
1712 #define EXTRACT_RETURN_VALUE(type, regcache, valbuf) (legacy_extract_return_value (type, regcache, valbuf))
1713 #endif
1714
1715 typedef void (gdbarch_extract_return_value_ftype) (struct type *type, struct regcache *regcache, void *valbuf);
1716 extern void gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf);
1717 extern void set_gdbarch_extract_return_value (struct gdbarch *gdbarch, gdbarch_extract_return_value_ftype *extract_return_value);
1718 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (EXTRACT_RETURN_VALUE)
1719 #error "Non multi-arch definition of EXTRACT_RETURN_VALUE"
1720 #endif
1721 #if GDB_MULTI_ARCH
1722 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_RETURN_VALUE)
1723 #define EXTRACT_RETURN_VALUE(type, regcache, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regcache, valbuf))
1724 #endif
1725 #endif
1726
1727 /* Default (function) for non- multi-arch platforms. */
1728 #if (!GDB_MULTI_ARCH) && !defined (STORE_RETURN_VALUE)
1729 #define STORE_RETURN_VALUE(type, regcache, valbuf) (legacy_store_return_value (type, regcache, valbuf))
1730 #endif
1731
1732 typedef void (gdbarch_store_return_value_ftype) (struct type *type, struct regcache *regcache, const void *valbuf);
1733 extern void gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf);
1734 extern void set_gdbarch_store_return_value (struct gdbarch *gdbarch, gdbarch_store_return_value_ftype *store_return_value);
1735 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STORE_RETURN_VALUE)
1736 #error "Non multi-arch definition of STORE_RETURN_VALUE"
1737 #endif
1738 #if GDB_MULTI_ARCH
1739 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STORE_RETURN_VALUE)
1740 #define STORE_RETURN_VALUE(type, regcache, valbuf) (gdbarch_store_return_value (current_gdbarch, type, regcache, valbuf))
1741 #endif
1742 #endif
1743
1744 typedef void (gdbarch_deprecated_extract_return_value_ftype) (struct type *type, char *regbuf, char *valbuf);
1745 extern void gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf);
1746 extern void set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value);
1747 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_EXTRACT_RETURN_VALUE)
1748 #error "Non multi-arch definition of DEPRECATED_EXTRACT_RETURN_VALUE"
1749 #endif
1750 #if GDB_MULTI_ARCH
1751 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_EXTRACT_RETURN_VALUE)
1752 #define DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf) (gdbarch_deprecated_extract_return_value (current_gdbarch, type, regbuf, valbuf))
1753 #endif
1754 #endif
1755
1756 typedef void (gdbarch_deprecated_store_return_value_ftype) (struct type *type, char *valbuf);
1757 extern void gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf);
1758 extern void set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value);
1759 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_STORE_RETURN_VALUE)
1760 #error "Non multi-arch definition of DEPRECATED_STORE_RETURN_VALUE"
1761 #endif
1762 #if GDB_MULTI_ARCH
1763 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_STORE_RETURN_VALUE)
1764 #define DEPRECATED_STORE_RETURN_VALUE(type, valbuf) (gdbarch_deprecated_store_return_value (current_gdbarch, type, valbuf))
1765 #endif
1766 #endif
1767
1768 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1769 /* Legacy for systems yet to multi-arch EXTRACT_STRUCT_VALUE_ADDRESS */
1770 #if !defined (EXTRACT_STRUCT_VALUE_ADDRESS_P)
1771 #define EXTRACT_STRUCT_VALUE_ADDRESS_P() (1)
1772 #endif
1773 #endif
1774
1775 /* Default predicate for non- multi-arch targets. */
1776 #if (!GDB_MULTI_ARCH) && !defined (EXTRACT_STRUCT_VALUE_ADDRESS_P)
1777 #define EXTRACT_STRUCT_VALUE_ADDRESS_P() (0)
1778 #endif
1779
1780 extern int gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch);
1781 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (EXTRACT_STRUCT_VALUE_ADDRESS_P)
1782 #error "Non multi-arch definition of EXTRACT_STRUCT_VALUE_ADDRESS"
1783 #endif
1784 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS_P)
1785 #define EXTRACT_STRUCT_VALUE_ADDRESS_P() (gdbarch_extract_struct_value_address_p (current_gdbarch))
1786 #endif
1787
1788 /* Default (function) for non- multi-arch platforms. */
1789 #if (!GDB_MULTI_ARCH) && !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1790 #define EXTRACT_STRUCT_VALUE_ADDRESS(regcache) (internal_error (__FILE__, __LINE__, "EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
1791 #endif
1792
1793 typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) (struct regcache *regcache);
1794 extern CORE_ADDR gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache);
1795 extern void set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, gdbarch_extract_struct_value_address_ftype *extract_struct_value_address);
1796 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1797 #error "Non multi-arch definition of EXTRACT_STRUCT_VALUE_ADDRESS"
1798 #endif
1799 #if GDB_MULTI_ARCH
1800 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1801 #define EXTRACT_STRUCT_VALUE_ADDRESS(regcache) (gdbarch_extract_struct_value_address (current_gdbarch, regcache))
1802 #endif
1803 #endif
1804
1805 #if defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS)
1806 /* Legacy for systems yet to multi-arch DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS */
1807 #if !defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P)
1808 #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() (1)
1809 #endif
1810 #endif
1811
1812 /* Default predicate for non- multi-arch targets. */
1813 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P)
1814 #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() (0)
1815 #endif
1816
1817 extern int gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch);
1818 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P)
1819 #error "Non multi-arch definition of DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS"
1820 #endif
1821 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P)
1822 #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() (gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch))
1823 #endif
1824
1825 /* Default (function) for non- multi-arch platforms. */
1826 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS)
1827 #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (internal_error (__FILE__, __LINE__, "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
1828 #endif
1829
1830 typedef CORE_ADDR (gdbarch_deprecated_extract_struct_value_address_ftype) (char *regbuf);
1831 extern CORE_ADDR gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf);
1832 extern void set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address);
1833 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS)
1834 #error "Non multi-arch definition of DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS"
1835 #endif
1836 #if GDB_MULTI_ARCH
1837 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS)
1838 #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (gdbarch_deprecated_extract_struct_value_address (current_gdbarch, regbuf))
1839 #endif
1840 #endif
1841
1842 /* Default (function) for non- multi-arch platforms. */
1843 #if (!GDB_MULTI_ARCH) && !defined (USE_STRUCT_CONVENTION)
1844 #define USE_STRUCT_CONVENTION(gcc_p, value_type) (generic_use_struct_convention (gcc_p, value_type))
1845 #endif
1846
1847 typedef int (gdbarch_use_struct_convention_ftype) (int gcc_p, struct type *value_type);
1848 extern int gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type);
1849 extern void set_gdbarch_use_struct_convention (struct gdbarch *gdbarch, gdbarch_use_struct_convention_ftype *use_struct_convention);
1850 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (USE_STRUCT_CONVENTION)
1851 #error "Non multi-arch definition of USE_STRUCT_CONVENTION"
1852 #endif
1853 #if GDB_MULTI_ARCH
1854 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (USE_STRUCT_CONVENTION)
1855 #define USE_STRUCT_CONVENTION(gcc_p, value_type) (gdbarch_use_struct_convention (current_gdbarch, gcc_p, value_type))
1856 #endif
1857 #endif
1858
1859 #if defined (DEPRECATED_FRAME_INIT_SAVED_REGS)
1860 /* Legacy for systems yet to multi-arch DEPRECATED_FRAME_INIT_SAVED_REGS */
1861 #if !defined (DEPRECATED_FRAME_INIT_SAVED_REGS_P)
1862 #define DEPRECATED_FRAME_INIT_SAVED_REGS_P() (1)
1863 #endif
1864 #endif
1865
1866 /* Default predicate for non- multi-arch targets. */
1867 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FRAME_INIT_SAVED_REGS_P)
1868 #define DEPRECATED_FRAME_INIT_SAVED_REGS_P() (0)
1869 #endif
1870
1871 extern int gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch *gdbarch);
1872 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FRAME_INIT_SAVED_REGS_P)
1873 #error "Non multi-arch definition of DEPRECATED_FRAME_INIT_SAVED_REGS"
1874 #endif
1875 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FRAME_INIT_SAVED_REGS_P)
1876 #define DEPRECATED_FRAME_INIT_SAVED_REGS_P() (gdbarch_deprecated_frame_init_saved_regs_p (current_gdbarch))
1877 #endif
1878
1879 /* Default (function) for non- multi-arch platforms. */
1880 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FRAME_INIT_SAVED_REGS)
1881 #define DEPRECATED_FRAME_INIT_SAVED_REGS(frame) (internal_error (__FILE__, __LINE__, "DEPRECATED_FRAME_INIT_SAVED_REGS"), 0)
1882 #endif
1883
1884 typedef void (gdbarch_deprecated_frame_init_saved_regs_ftype) (struct frame_info *frame);
1885 extern void gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame);
1886 extern void set_gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, gdbarch_deprecated_frame_init_saved_regs_ftype *deprecated_frame_init_saved_regs);
1887 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FRAME_INIT_SAVED_REGS)
1888 #error "Non multi-arch definition of DEPRECATED_FRAME_INIT_SAVED_REGS"
1889 #endif
1890 #if GDB_MULTI_ARCH
1891 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FRAME_INIT_SAVED_REGS)
1892 #define DEPRECATED_FRAME_INIT_SAVED_REGS(frame) (gdbarch_deprecated_frame_init_saved_regs (current_gdbarch, frame))
1893 #endif
1894 #endif
1895
1896 #if defined (DEPRECATED_INIT_EXTRA_FRAME_INFO)
1897 /* Legacy for systems yet to multi-arch DEPRECATED_INIT_EXTRA_FRAME_INFO */
1898 #if !defined (DEPRECATED_INIT_EXTRA_FRAME_INFO_P)
1899 #define DEPRECATED_INIT_EXTRA_FRAME_INFO_P() (1)
1900 #endif
1901 #endif
1902
1903 /* Default predicate for non- multi-arch targets. */
1904 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_INIT_EXTRA_FRAME_INFO_P)
1905 #define DEPRECATED_INIT_EXTRA_FRAME_INFO_P() (0)
1906 #endif
1907
1908 extern int gdbarch_deprecated_init_extra_frame_info_p (struct gdbarch *gdbarch);
1909 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_INIT_EXTRA_FRAME_INFO_P)
1910 #error "Non multi-arch definition of DEPRECATED_INIT_EXTRA_FRAME_INFO"
1911 #endif
1912 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_INIT_EXTRA_FRAME_INFO_P)
1913 #define DEPRECATED_INIT_EXTRA_FRAME_INFO_P() (gdbarch_deprecated_init_extra_frame_info_p (current_gdbarch))
1914 #endif
1915
1916 /* Default (function) for non- multi-arch platforms. */
1917 #if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_INIT_EXTRA_FRAME_INFO)
1918 #define DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame) (internal_error (__FILE__, __LINE__, "DEPRECATED_INIT_EXTRA_FRAME_INFO"), 0)
1919 #endif
1920
1921 typedef void (gdbarch_deprecated_init_extra_frame_info_ftype) (int fromleaf, struct frame_info *frame);
1922 extern void gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame);
1923 extern void set_gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, gdbarch_deprecated_init_extra_frame_info_ftype *deprecated_init_extra_frame_info);
1924 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_INIT_EXTRA_FRAME_INFO)
1925 #error "Non multi-arch definition of DEPRECATED_INIT_EXTRA_FRAME_INFO"
1926 #endif
1927 #if GDB_MULTI_ARCH
1928 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_INIT_EXTRA_FRAME_INFO)
1929 #define DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame) (gdbarch_deprecated_init_extra_frame_info (current_gdbarch, fromleaf, frame))
1930 #endif
1931 #endif
1932
1933 typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (CORE_ADDR ip);
1934 extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
1935 extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
1936 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SKIP_PROLOGUE)
1937 #error "Non multi-arch definition of SKIP_PROLOGUE"
1938 #endif
1939 #if GDB_MULTI_ARCH
1940 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SKIP_PROLOGUE)
1941 #define SKIP_PROLOGUE(ip) (gdbarch_skip_prologue (current_gdbarch, ip))
1942 #endif
1943 #endif
1944
1945 /* Default (function) for non- multi-arch platforms. */
1946 #if (!GDB_MULTI_ARCH) && !defined (PROLOGUE_FRAMELESS_P)
1947 #define PROLOGUE_FRAMELESS_P(ip) (generic_prologue_frameless_p (ip))
1948 #endif
1949
1950 typedef int (gdbarch_prologue_frameless_p_ftype) (CORE_ADDR ip);
1951 extern int gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip);
1952 extern void set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, gdbarch_prologue_frameless_p_ftype *prologue_frameless_p);
1953 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PROLOGUE_FRAMELESS_P)
1954 #error "Non multi-arch definition of PROLOGUE_FRAMELESS_P"
1955 #endif
1956 #if GDB_MULTI_ARCH
1957 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PROLOGUE_FRAMELESS_P)
1958 #define PROLOGUE_FRAMELESS_P(ip) (gdbarch_prologue_frameless_p (current_gdbarch, ip))
1959 #endif
1960 #endif
1961
1962 typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
1963 extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
1964 extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
1965 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (INNER_THAN)
1966 #error "Non multi-arch definition of INNER_THAN"
1967 #endif
1968 #if GDB_MULTI_ARCH
1969 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (INNER_THAN)
1970 #define INNER_THAN(lhs, rhs) (gdbarch_inner_than (current_gdbarch, lhs, rhs))
1971 #endif
1972 #endif
1973
1974 /* Default (function) for non- multi-arch platforms. */
1975 #if (!GDB_MULTI_ARCH) && !defined (BREAKPOINT_FROM_PC)
1976 #define BREAKPOINT_FROM_PC(pcptr, lenptr) (legacy_breakpoint_from_pc (pcptr, lenptr))
1977 #endif
1978
1979 typedef const unsigned char * (gdbarch_breakpoint_from_pc_ftype) (CORE_ADDR *pcptr, int *lenptr);
1980 extern const unsigned char * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
1981 extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
1982 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (BREAKPOINT_FROM_PC)
1983 #error "Non multi-arch definition of BREAKPOINT_FROM_PC"
1984 #endif
1985 #if GDB_MULTI_ARCH
1986 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (BREAKPOINT_FROM_PC)
1987 #define BREAKPOINT_FROM_PC(pcptr, lenptr) (gdbarch_breakpoint_from_pc (current_gdbarch, pcptr, lenptr))
1988 #endif
1989 #endif
1990
1991 /* Default (function) for non- multi-arch platforms. */
1992 #if (!GDB_MULTI_ARCH) && !defined (MEMORY_INSERT_BREAKPOINT)
1993 #define MEMORY_INSERT_BREAKPOINT(addr, contents_cache) (default_memory_insert_breakpoint (addr, contents_cache))
1994 #endif
1995
1996 typedef int (gdbarch_memory_insert_breakpoint_ftype) (CORE_ADDR addr, char *contents_cache);
1997 extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache);
1998 extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
1999 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (MEMORY_INSERT_BREAKPOINT)
2000 #error "Non multi-arch definition of MEMORY_INSERT_BREAKPOINT"
2001 #endif
2002 #if GDB_MULTI_ARCH
2003 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MEMORY_INSERT_BREAKPOINT)
2004 #define MEMORY_INSERT_BREAKPOINT(addr, contents_cache) (gdbarch_memory_insert_breakpoint (current_gdbarch, addr, contents_cache))
2005 #endif
2006 #endif
2007
2008 /* Default (function) for non- multi-arch platforms. */
2009 #if (!GDB_MULTI_ARCH) && !defined (MEMORY_REMOVE_BREAKPOINT)
2010 #define MEMORY_REMOVE_BREAKPOINT(addr, contents_cache) (default_memory_remove_breakpoint (addr, contents_cache))
2011 #endif
2012
2013 typedef int (gdbarch_memory_remove_breakpoint_ftype) (CORE_ADDR addr, char *contents_cache);
2014 extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache);
2015 extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
2016 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (MEMORY_REMOVE_BREAKPOINT)
2017 #error "Non multi-arch definition of MEMORY_REMOVE_BREAKPOINT"
2018 #endif
2019 #if GDB_MULTI_ARCH
2020 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MEMORY_REMOVE_BREAKPOINT)
2021 #define MEMORY_REMOVE_BREAKPOINT(addr, contents_cache) (gdbarch_memory_remove_breakpoint (current_gdbarch, addr, contents_cache))
2022 #endif
2023 #endif
2024
2025 extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
2026 extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
2027 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DECR_PC_AFTER_BREAK)
2028 #error "Non multi-arch definition of DECR_PC_AFTER_BREAK"
2029 #endif
2030 #if GDB_MULTI_ARCH
2031 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DECR_PC_AFTER_BREAK)
2032 #define DECR_PC_AFTER_BREAK (gdbarch_decr_pc_after_break (current_gdbarch))
2033 #endif
2034 #endif
2035
2036 /* Default (function) for non- multi-arch platforms. */
2037 #if (!GDB_MULTI_ARCH) && !defined (PREPARE_TO_PROCEED)
2038 #define PREPARE_TO_PROCEED(select_it) (default_prepare_to_proceed (select_it))
2039 #endif
2040
2041 typedef int (gdbarch_prepare_to_proceed_ftype) (int select_it);
2042 extern int gdbarch_prepare_to_proceed (struct gdbarch *gdbarch, int select_it);
2043 extern void set_gdbarch_prepare_to_proceed (struct gdbarch *gdbarch, gdbarch_prepare_to_proceed_ftype *prepare_to_proceed);
2044 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PREPARE_TO_PROCEED)
2045 #error "Non multi-arch definition of PREPARE_TO_PROCEED"
2046 #endif
2047 #if GDB_MULTI_ARCH
2048 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PREPARE_TO_PROCEED)
2049 #define PREPARE_TO_PROCEED(select_it) (gdbarch_prepare_to_proceed (current_gdbarch, select_it))
2050 #endif
2051 #endif
2052
2053 extern CORE_ADDR gdbarch_function_start_offset (struct gdbarch *gdbarch);
2054 extern void set_gdbarch_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR function_start_offset);
2055 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FUNCTION_START_OFFSET)
2056 #error "Non multi-arch definition of FUNCTION_START_OFFSET"
2057 #endif
2058 #if GDB_MULTI_ARCH
2059 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FUNCTION_START_OFFSET)
2060 #define FUNCTION_START_OFFSET (gdbarch_function_start_offset (current_gdbarch))
2061 #endif
2062 #endif
2063
2064 /* Default (function) for non- multi-arch platforms. */
2065 #if (!GDB_MULTI_ARCH) && !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
2066 #define REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len) (generic_remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len))
2067 #endif
2068
2069 typedef void (gdbarch_remote_translate_xfer_address_ftype) (CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
2070 extern void gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
2071 extern void set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address);
2072 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REMOTE_TRANSLATE_XFER_ADDRESS)
2073 #error "Non multi-arch definition of REMOTE_TRANSLATE_XFER_ADDRESS"
2074 #endif
2075 #if GDB_MULTI_ARCH
2076 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
2077 #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))
2078 #endif
2079 #endif
2080
2081 extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
2082 extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
2083 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_ARGS_SKIP)
2084 #error "Non multi-arch definition of FRAME_ARGS_SKIP"
2085 #endif
2086 #if GDB_MULTI_ARCH
2087 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_ARGS_SKIP)
2088 #define FRAME_ARGS_SKIP (gdbarch_frame_args_skip (current_gdbarch))
2089 #endif
2090 #endif
2091
2092 /* Default (function) for non- multi-arch platforms. */
2093 #if (!GDB_MULTI_ARCH) && !defined (FRAMELESS_FUNCTION_INVOCATION)
2094 #define FRAMELESS_FUNCTION_INVOCATION(fi) (generic_frameless_function_invocation_not (fi))
2095 #endif
2096
2097 typedef int (gdbarch_frameless_function_invocation_ftype) (struct frame_info *fi);
2098 extern int gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi);
2099 extern void set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, gdbarch_frameless_function_invocation_ftype *frameless_function_invocation);
2100 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAMELESS_FUNCTION_INVOCATION)
2101 #error "Non multi-arch definition of FRAMELESS_FUNCTION_INVOCATION"
2102 #endif
2103 #if GDB_MULTI_ARCH
2104 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAMELESS_FUNCTION_INVOCATION)
2105 #define FRAMELESS_FUNCTION_INVOCATION(fi) (gdbarch_frameless_function_invocation (current_gdbarch, fi))
2106 #endif
2107 #endif
2108
2109 #if defined (FRAME_CHAIN)
2110 /* Legacy for systems yet to multi-arch FRAME_CHAIN */
2111 #if !defined (FRAME_CHAIN_P)
2112 #define FRAME_CHAIN_P() (1)
2113 #endif
2114 #endif
2115
2116 /* Default predicate for non- multi-arch targets. */
2117 #if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN_P)
2118 #define FRAME_CHAIN_P() (0)
2119 #endif
2120
2121 extern int gdbarch_frame_chain_p (struct gdbarch *gdbarch);
2122 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN_P)
2123 #error "Non multi-arch definition of FRAME_CHAIN"
2124 #endif
2125 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_P)
2126 #define FRAME_CHAIN_P() (gdbarch_frame_chain_p (current_gdbarch))
2127 #endif
2128
2129 /* Default (function) for non- multi-arch platforms. */
2130 #if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN)
2131 #define FRAME_CHAIN(frame) (internal_error (__FILE__, __LINE__, "FRAME_CHAIN"), 0)
2132 #endif
2133
2134 typedef CORE_ADDR (gdbarch_frame_chain_ftype) (struct frame_info *frame);
2135 extern CORE_ADDR gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame);
2136 extern void set_gdbarch_frame_chain (struct gdbarch *gdbarch, gdbarch_frame_chain_ftype *frame_chain);
2137 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN)
2138 #error "Non multi-arch definition of FRAME_CHAIN"
2139 #endif
2140 #if GDB_MULTI_ARCH
2141 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN)
2142 #define FRAME_CHAIN(frame) (gdbarch_frame_chain (current_gdbarch, frame))
2143 #endif
2144 #endif
2145
2146 #if defined (FRAME_CHAIN_VALID)
2147 /* Legacy for systems yet to multi-arch FRAME_CHAIN_VALID */
2148 #if !defined (FRAME_CHAIN_VALID_P)
2149 #define FRAME_CHAIN_VALID_P() (1)
2150 #endif
2151 #endif
2152
2153 /* Default predicate for non- multi-arch targets. */
2154 #if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN_VALID_P)
2155 #define FRAME_CHAIN_VALID_P() (0)
2156 #endif
2157
2158 extern int gdbarch_frame_chain_valid_p (struct gdbarch *gdbarch);
2159 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN_VALID_P)
2160 #error "Non multi-arch definition of FRAME_CHAIN_VALID"
2161 #endif
2162 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_VALID_P)
2163 #define FRAME_CHAIN_VALID_P() (gdbarch_frame_chain_valid_p (current_gdbarch))
2164 #endif
2165
2166 /* Default (function) for non- multi-arch platforms. */
2167 #if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN_VALID)
2168 #define FRAME_CHAIN_VALID(chain, thisframe) (internal_error (__FILE__, __LINE__, "FRAME_CHAIN_VALID"), 0)
2169 #endif
2170
2171 typedef int (gdbarch_frame_chain_valid_ftype) (CORE_ADDR chain, struct frame_info *thisframe);
2172 extern int gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe);
2173 extern void set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch, gdbarch_frame_chain_valid_ftype *frame_chain_valid);
2174 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN_VALID)
2175 #error "Non multi-arch definition of FRAME_CHAIN_VALID"
2176 #endif
2177 #if GDB_MULTI_ARCH
2178 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_VALID)
2179 #define FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_frame_chain_valid (current_gdbarch, chain, thisframe))
2180 #endif
2181 #endif
2182
2183 #if defined (FRAME_SAVED_PC)
2184 /* Legacy for systems yet to multi-arch FRAME_SAVED_PC */
2185 #if !defined (FRAME_SAVED_PC_P)
2186 #define FRAME_SAVED_PC_P() (1)
2187 #endif
2188 #endif
2189
2190 /* Default predicate for non- multi-arch targets. */
2191 #if (!GDB_MULTI_ARCH) && !defined (FRAME_SAVED_PC_P)
2192 #define FRAME_SAVED_PC_P() (0)
2193 #endif
2194
2195 extern int gdbarch_frame_saved_pc_p (struct gdbarch *gdbarch);
2196 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_SAVED_PC_P)
2197 #error "Non multi-arch definition of FRAME_SAVED_PC"
2198 #endif
2199 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_SAVED_PC_P)
2200 #define FRAME_SAVED_PC_P() (gdbarch_frame_saved_pc_p (current_gdbarch))
2201 #endif
2202
2203 /* Default (function) for non- multi-arch platforms. */
2204 #if (!GDB_MULTI_ARCH) && !defined (FRAME_SAVED_PC)
2205 #define FRAME_SAVED_PC(fi) (internal_error (__FILE__, __LINE__, "FRAME_SAVED_PC"), 0)
2206 #endif
2207
2208 typedef CORE_ADDR (gdbarch_frame_saved_pc_ftype) (struct frame_info *fi);
2209 extern CORE_ADDR gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi);
2210 extern void set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch, gdbarch_frame_saved_pc_ftype *frame_saved_pc);
2211 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_SAVED_PC)
2212 #error "Non multi-arch definition of FRAME_SAVED_PC"
2213 #endif
2214 #if GDB_MULTI_ARCH
2215 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_SAVED_PC)
2216 #define FRAME_SAVED_PC(fi) (gdbarch_frame_saved_pc (current_gdbarch, fi))
2217 #endif
2218 #endif
2219
2220 /* Default (function) for non- multi-arch platforms. */
2221 #if (!GDB_MULTI_ARCH) && !defined (FRAME_ARGS_ADDRESS)
2222 #define FRAME_ARGS_ADDRESS(fi) (get_frame_base (fi))
2223 #endif
2224
2225 typedef CORE_ADDR (gdbarch_frame_args_address_ftype) (struct frame_info *fi);
2226 extern CORE_ADDR gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi);
2227 extern void set_gdbarch_frame_args_address (struct gdbarch *gdbarch, gdbarch_frame_args_address_ftype *frame_args_address);
2228 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_ARGS_ADDRESS)
2229 #error "Non multi-arch definition of FRAME_ARGS_ADDRESS"
2230 #endif
2231 #if GDB_MULTI_ARCH
2232 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_ARGS_ADDRESS)
2233 #define FRAME_ARGS_ADDRESS(fi) (gdbarch_frame_args_address (current_gdbarch, fi))
2234 #endif
2235 #endif
2236
2237 /* Default (function) for non- multi-arch platforms. */
2238 #if (!GDB_MULTI_ARCH) && !defined (FRAME_LOCALS_ADDRESS)
2239 #define FRAME_LOCALS_ADDRESS(fi) (get_frame_base (fi))
2240 #endif
2241
2242 typedef CORE_ADDR (gdbarch_frame_locals_address_ftype) (struct frame_info *fi);
2243 extern CORE_ADDR gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi);
2244 extern void set_gdbarch_frame_locals_address (struct gdbarch *gdbarch, gdbarch_frame_locals_address_ftype *frame_locals_address);
2245 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_LOCALS_ADDRESS)
2246 #error "Non multi-arch definition of FRAME_LOCALS_ADDRESS"
2247 #endif
2248 #if GDB_MULTI_ARCH
2249 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_LOCALS_ADDRESS)
2250 #define FRAME_LOCALS_ADDRESS(fi) (gdbarch_frame_locals_address (current_gdbarch, fi))
2251 #endif
2252 #endif
2253
2254 typedef CORE_ADDR (gdbarch_saved_pc_after_call_ftype) (struct frame_info *frame);
2255 extern CORE_ADDR gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame);
2256 extern void set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, gdbarch_saved_pc_after_call_ftype *saved_pc_after_call);
2257 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SAVED_PC_AFTER_CALL)
2258 #error "Non multi-arch definition of SAVED_PC_AFTER_CALL"
2259 #endif
2260 #if GDB_MULTI_ARCH
2261 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SAVED_PC_AFTER_CALL)
2262 #define SAVED_PC_AFTER_CALL(frame) (gdbarch_saved_pc_after_call (current_gdbarch, frame))
2263 #endif
2264 #endif
2265
2266 typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
2267 extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
2268 extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
2269 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_NUM_ARGS)
2270 #error "Non multi-arch definition of FRAME_NUM_ARGS"
2271 #endif
2272 #if GDB_MULTI_ARCH
2273 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_NUM_ARGS)
2274 #define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame))
2275 #endif
2276 #endif
2277
2278 #if defined (STACK_ALIGN)
2279 /* Legacy for systems yet to multi-arch STACK_ALIGN */
2280 #if !defined (STACK_ALIGN_P)
2281 #define STACK_ALIGN_P() (1)
2282 #endif
2283 #endif
2284
2285 /* Default predicate for non- multi-arch targets. */
2286 #if (!GDB_MULTI_ARCH) && !defined (STACK_ALIGN_P)
2287 #define STACK_ALIGN_P() (0)
2288 #endif
2289
2290 extern int gdbarch_stack_align_p (struct gdbarch *gdbarch);
2291 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STACK_ALIGN_P)
2292 #error "Non multi-arch definition of STACK_ALIGN"
2293 #endif
2294 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STACK_ALIGN_P)
2295 #define STACK_ALIGN_P() (gdbarch_stack_align_p (current_gdbarch))
2296 #endif
2297
2298 /* Default (function) for non- multi-arch platforms. */
2299 #if (!GDB_MULTI_ARCH) && !defined (STACK_ALIGN)
2300 #define STACK_ALIGN(sp) (internal_error (__FILE__, __LINE__, "STACK_ALIGN"), 0)
2301 #endif
2302
2303 typedef CORE_ADDR (gdbarch_stack_align_ftype) (CORE_ADDR sp);
2304 extern CORE_ADDR gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp);
2305 extern void set_gdbarch_stack_align (struct gdbarch *gdbarch, gdbarch_stack_align_ftype *stack_align);
2306 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STACK_ALIGN)
2307 #error "Non multi-arch definition of STACK_ALIGN"
2308 #endif
2309 #if GDB_MULTI_ARCH
2310 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STACK_ALIGN)
2311 #define STACK_ALIGN(sp) (gdbarch_stack_align (current_gdbarch, sp))
2312 #endif
2313 #endif
2314
2315 extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);
2316
2317 typedef CORE_ADDR (gdbarch_frame_align_ftype) (struct gdbarch *gdbarch, CORE_ADDR address);
2318 extern CORE_ADDR gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address);
2319 extern void set_gdbarch_frame_align (struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align);
2320
2321 /* Default (value) for non- multi-arch platforms. */
2322 #if (!GDB_MULTI_ARCH) && !defined (EXTRA_STACK_ALIGNMENT_NEEDED)
2323 #define EXTRA_STACK_ALIGNMENT_NEEDED (1)
2324 #endif
2325
2326 extern int gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch);
2327 extern void set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch, int extra_stack_alignment_needed);
2328 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (EXTRA_STACK_ALIGNMENT_NEEDED)
2329 #error "Non multi-arch definition of EXTRA_STACK_ALIGNMENT_NEEDED"
2330 #endif
2331 #if GDB_MULTI_ARCH
2332 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRA_STACK_ALIGNMENT_NEEDED)
2333 #define EXTRA_STACK_ALIGNMENT_NEEDED (gdbarch_extra_stack_alignment_needed (current_gdbarch))
2334 #endif
2335 #endif
2336
2337 #if defined (REG_STRUCT_HAS_ADDR)
2338 /* Legacy for systems yet to multi-arch REG_STRUCT_HAS_ADDR */
2339 #if !defined (REG_STRUCT_HAS_ADDR_P)
2340 #define REG_STRUCT_HAS_ADDR_P() (1)
2341 #endif
2342 #endif
2343
2344 /* Default predicate for non- multi-arch targets. */
2345 #if (!GDB_MULTI_ARCH) && !defined (REG_STRUCT_HAS_ADDR_P)
2346 #define REG_STRUCT_HAS_ADDR_P() (0)
2347 #endif
2348
2349 extern int gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch);
2350 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REG_STRUCT_HAS_ADDR_P)
2351 #error "Non multi-arch definition of REG_STRUCT_HAS_ADDR"
2352 #endif
2353 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REG_STRUCT_HAS_ADDR_P)
2354 #define REG_STRUCT_HAS_ADDR_P() (gdbarch_reg_struct_has_addr_p (current_gdbarch))
2355 #endif
2356
2357 /* Default (function) for non- multi-arch platforms. */
2358 #if (!GDB_MULTI_ARCH) && !defined (REG_STRUCT_HAS_ADDR)
2359 #define REG_STRUCT_HAS_ADDR(gcc_p, type) (internal_error (__FILE__, __LINE__, "REG_STRUCT_HAS_ADDR"), 0)
2360 #endif
2361
2362 typedef int (gdbarch_reg_struct_has_addr_ftype) (int gcc_p, struct type *type);
2363 extern int gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type);
2364 extern void set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr);
2365 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REG_STRUCT_HAS_ADDR)
2366 #error "Non multi-arch definition of REG_STRUCT_HAS_ADDR"
2367 #endif
2368 #if GDB_MULTI_ARCH
2369 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REG_STRUCT_HAS_ADDR)
2370 #define REG_STRUCT_HAS_ADDR(gcc_p, type) (gdbarch_reg_struct_has_addr (current_gdbarch, gcc_p, type))
2371 #endif
2372 #endif
2373
2374 #if defined (SAVE_DUMMY_FRAME_TOS)
2375 /* Legacy for systems yet to multi-arch SAVE_DUMMY_FRAME_TOS */
2376 #if !defined (SAVE_DUMMY_FRAME_TOS_P)
2377 #define SAVE_DUMMY_FRAME_TOS_P() (1)
2378 #endif
2379 #endif
2380
2381 /* Default predicate for non- multi-arch targets. */
2382 #if (!GDB_MULTI_ARCH) && !defined (SAVE_DUMMY_FRAME_TOS_P)
2383 #define SAVE_DUMMY_FRAME_TOS_P() (0)
2384 #endif
2385
2386 extern int gdbarch_save_dummy_frame_tos_p (struct gdbarch *gdbarch);
2387 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SAVE_DUMMY_FRAME_TOS_P)
2388 #error "Non multi-arch definition of SAVE_DUMMY_FRAME_TOS"
2389 #endif
2390 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SAVE_DUMMY_FRAME_TOS_P)
2391 #define SAVE_DUMMY_FRAME_TOS_P() (gdbarch_save_dummy_frame_tos_p (current_gdbarch))
2392 #endif
2393
2394 /* Default (function) for non- multi-arch platforms. */
2395 #if (!GDB_MULTI_ARCH) && !defined (SAVE_DUMMY_FRAME_TOS)
2396 #define SAVE_DUMMY_FRAME_TOS(sp) (internal_error (__FILE__, __LINE__, "SAVE_DUMMY_FRAME_TOS"), 0)
2397 #endif
2398
2399 typedef void (gdbarch_save_dummy_frame_tos_ftype) (CORE_ADDR sp);
2400 extern void gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp);
2401 extern void set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos);
2402 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SAVE_DUMMY_FRAME_TOS)
2403 #error "Non multi-arch definition of SAVE_DUMMY_FRAME_TOS"
2404 #endif
2405 #if GDB_MULTI_ARCH
2406 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SAVE_DUMMY_FRAME_TOS)
2407 #define SAVE_DUMMY_FRAME_TOS(sp) (gdbarch_save_dummy_frame_tos (current_gdbarch, sp))
2408 #endif
2409 #endif
2410
2411 extern int gdbarch_parm_boundary (struct gdbarch *gdbarch);
2412 extern void set_gdbarch_parm_boundary (struct gdbarch *gdbarch, int parm_boundary);
2413 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PARM_BOUNDARY)
2414 #error "Non multi-arch definition of PARM_BOUNDARY"
2415 #endif
2416 #if GDB_MULTI_ARCH
2417 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PARM_BOUNDARY)
2418 #define PARM_BOUNDARY (gdbarch_parm_boundary (current_gdbarch))
2419 #endif
2420 #endif
2421
2422 /* Default (value) for non- multi-arch platforms. */
2423 #if (!GDB_MULTI_ARCH) && !defined (TARGET_FLOAT_FORMAT)
2424 #define TARGET_FLOAT_FORMAT (default_float_format (current_gdbarch))
2425 #endif
2426
2427 extern const struct floatformat * gdbarch_float_format (struct gdbarch *gdbarch);
2428 extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat * float_format);
2429 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_FLOAT_FORMAT)
2430 #error "Non multi-arch definition of TARGET_FLOAT_FORMAT"
2431 #endif
2432 #if GDB_MULTI_ARCH
2433 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_FLOAT_FORMAT)
2434 #define TARGET_FLOAT_FORMAT (gdbarch_float_format (current_gdbarch))
2435 #endif
2436 #endif
2437
2438 /* Default (value) for non- multi-arch platforms. */
2439 #if (!GDB_MULTI_ARCH) && !defined (TARGET_DOUBLE_FORMAT)
2440 #define TARGET_DOUBLE_FORMAT (default_double_format (current_gdbarch))
2441 #endif
2442
2443 extern const struct floatformat * gdbarch_double_format (struct gdbarch *gdbarch);
2444 extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat * double_format);
2445 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_DOUBLE_FORMAT)
2446 #error "Non multi-arch definition of TARGET_DOUBLE_FORMAT"
2447 #endif
2448 #if GDB_MULTI_ARCH
2449 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_DOUBLE_FORMAT)
2450 #define TARGET_DOUBLE_FORMAT (gdbarch_double_format (current_gdbarch))
2451 #endif
2452 #endif
2453
2454 /* Default (value) for non- multi-arch platforms. */
2455 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_DOUBLE_FORMAT)
2456 #define TARGET_LONG_DOUBLE_FORMAT (default_double_format (current_gdbarch))
2457 #endif
2458
2459 extern const struct floatformat * gdbarch_long_double_format (struct gdbarch *gdbarch);
2460 extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat * long_double_format);
2461 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_LONG_DOUBLE_FORMAT)
2462 #error "Non multi-arch definition of TARGET_LONG_DOUBLE_FORMAT"
2463 #endif
2464 #if GDB_MULTI_ARCH
2465 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_DOUBLE_FORMAT)
2466 #define TARGET_LONG_DOUBLE_FORMAT (gdbarch_long_double_format (current_gdbarch))
2467 #endif
2468 #endif
2469
2470 /* Default (function) for non- multi-arch platforms. */
2471 #if (!GDB_MULTI_ARCH) && !defined (CONVERT_FROM_FUNC_PTR_ADDR)
2472 #define CONVERT_FROM_FUNC_PTR_ADDR(addr) (core_addr_identity (addr))
2473 #endif
2474
2475 typedef CORE_ADDR (gdbarch_convert_from_func_ptr_addr_ftype) (CORE_ADDR addr);
2476 extern CORE_ADDR gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr);
2477 extern void set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr);
2478 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CONVERT_FROM_FUNC_PTR_ADDR)
2479 #error "Non multi-arch definition of CONVERT_FROM_FUNC_PTR_ADDR"
2480 #endif
2481 #if GDB_MULTI_ARCH
2482 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CONVERT_FROM_FUNC_PTR_ADDR)
2483 #define CONVERT_FROM_FUNC_PTR_ADDR(addr) (gdbarch_convert_from_func_ptr_addr (current_gdbarch, addr))
2484 #endif
2485 #endif
2486
2487 /* On some machines there are bits in addresses which are not really
2488    part of the address, but are used by the kernel, the hardware, etc.
2489    for special purposes.  ADDR_BITS_REMOVE takes out any such bits so
2490    we get a "real" address such as one would find in a symbol table.
2491    This is used only for addresses of instructions, and even then I'm
2492    not sure it's used in all contexts.  It exists to deal with there
2493    being a few stray bits in the PC which would mislead us, not as some
2494    sort of generic thing to handle alignment or segmentation (it's
2495    possible it should be in TARGET_READ_PC instead). */
2496
2497 /* Default (function) for non- multi-arch platforms. */
2498 #if (!GDB_MULTI_ARCH) && !defined (ADDR_BITS_REMOVE)
2499 #define ADDR_BITS_REMOVE(addr) (core_addr_identity (addr))
2500 #endif
2501
2502 typedef CORE_ADDR (gdbarch_addr_bits_remove_ftype) (CORE_ADDR addr);
2503 extern CORE_ADDR gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr);
2504 extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove);
2505 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (ADDR_BITS_REMOVE)
2506 #error "Non multi-arch definition of ADDR_BITS_REMOVE"
2507 #endif
2508 #if GDB_MULTI_ARCH
2509 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ADDR_BITS_REMOVE)
2510 #define ADDR_BITS_REMOVE(addr) (gdbarch_addr_bits_remove (current_gdbarch, addr))
2511 #endif
2512 #endif
2513
2514 /* It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
2515    ADDR_BITS_REMOVE. */
2516
2517 /* Default (function) for non- multi-arch platforms. */
2518 #if (!GDB_MULTI_ARCH) && !defined (SMASH_TEXT_ADDRESS)
2519 #define SMASH_TEXT_ADDRESS(addr) (core_addr_identity (addr))
2520 #endif
2521
2522 typedef CORE_ADDR (gdbarch_smash_text_address_ftype) (CORE_ADDR addr);
2523 extern CORE_ADDR gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr);
2524 extern void set_gdbarch_smash_text_address (struct gdbarch *gdbarch, gdbarch_smash_text_address_ftype *smash_text_address);
2525 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SMASH_TEXT_ADDRESS)
2526 #error "Non multi-arch definition of SMASH_TEXT_ADDRESS"
2527 #endif
2528 #if GDB_MULTI_ARCH
2529 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SMASH_TEXT_ADDRESS)
2530 #define SMASH_TEXT_ADDRESS(addr) (gdbarch_smash_text_address (current_gdbarch, addr))
2531 #endif
2532 #endif
2533
2534 /* FIXME/cagney/2001-01-18: This should be split in two.  A target method that indicates if
2535    the target needs software single step.  An ISA method to implement it.
2536
2537    FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
2538    using the breakpoint system instead of blatting memory directly (as with rs6000).
2539
2540    FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the target can
2541    single step.  If not, then implement single step using breakpoints. */
2542
2543 #if defined (SOFTWARE_SINGLE_STEP)
2544 /* Legacy for systems yet to multi-arch SOFTWARE_SINGLE_STEP */
2545 #if !defined (SOFTWARE_SINGLE_STEP_P)
2546 #define SOFTWARE_SINGLE_STEP_P() (1)
2547 #endif
2548 #endif
2549
2550 /* Default predicate for non- multi-arch targets. */
2551 #if (!GDB_MULTI_ARCH) && !defined (SOFTWARE_SINGLE_STEP_P)
2552 #define SOFTWARE_SINGLE_STEP_P() (0)
2553 #endif
2554
2555 extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
2556 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SOFTWARE_SINGLE_STEP_P)
2557 #error "Non multi-arch definition of SOFTWARE_SINGLE_STEP"
2558 #endif
2559 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SOFTWARE_SINGLE_STEP_P)
2560 #define SOFTWARE_SINGLE_STEP_P() (gdbarch_software_single_step_p (current_gdbarch))
2561 #endif
2562
2563 /* Default (function) for non- multi-arch platforms. */
2564 #if (!GDB_MULTI_ARCH) && !defined (SOFTWARE_SINGLE_STEP)
2565 #define SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p) (internal_error (__FILE__, __LINE__, "SOFTWARE_SINGLE_STEP"), 0)
2566 #endif
2567
2568 typedef void (gdbarch_software_single_step_ftype) (enum target_signal sig, int insert_breakpoints_p);
2569 extern void gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p);
2570 extern void set_gdbarch_software_single_step (struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step);
2571 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SOFTWARE_SINGLE_STEP)
2572 #error "Non multi-arch definition of SOFTWARE_SINGLE_STEP"
2573 #endif
2574 #if GDB_MULTI_ARCH
2575 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SOFTWARE_SINGLE_STEP)
2576 #define SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p) (gdbarch_software_single_step (current_gdbarch, sig, insert_breakpoints_p))
2577 #endif
2578 #endif
2579
2580 /* Default (function) for non- multi-arch platforms. */
2581 #if (!GDB_MULTI_ARCH) && !defined (TARGET_PRINT_INSN)
2582 #define TARGET_PRINT_INSN(vma, info) (legacy_print_insn (vma, info))
2583 #endif
2584
2585 typedef int (gdbarch_print_insn_ftype) (bfd_vma vma, disassemble_info *info);
2586 extern int gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, disassemble_info *info);
2587 extern void set_gdbarch_print_insn (struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn);
2588 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (TARGET_PRINT_INSN)
2589 #error "Non multi-arch definition of TARGET_PRINT_INSN"
2590 #endif
2591 #if GDB_MULTI_ARCH
2592 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_PRINT_INSN)
2593 #define TARGET_PRINT_INSN(vma, info) (gdbarch_print_insn (current_gdbarch, vma, info))
2594 #endif
2595 #endif
2596
2597 /* Default (function) for non- multi-arch platforms. */
2598 #if (!GDB_MULTI_ARCH) && !defined (SKIP_TRAMPOLINE_CODE)
2599 #define SKIP_TRAMPOLINE_CODE(pc) (generic_skip_trampoline_code (pc))
2600 #endif
2601
2602 typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (CORE_ADDR pc);
2603 extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc);
2604 extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code);
2605 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SKIP_TRAMPOLINE_CODE)
2606 #error "Non multi-arch definition of SKIP_TRAMPOLINE_CODE"
2607 #endif
2608 #if GDB_MULTI_ARCH
2609 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SKIP_TRAMPOLINE_CODE)
2610 #define SKIP_TRAMPOLINE_CODE(pc) (gdbarch_skip_trampoline_code (current_gdbarch, pc))
2611 #endif
2612 #endif
2613
2614 /* For SVR4 shared libraries, each call goes through a small piece of
2615    trampoline code in the ".plt" section.  IN_SOLIB_CALL_TRAMPOLINE evaluates
2616    to nonzero if we are currently stopped in one of these. */
2617
2618 /* Default (function) for non- multi-arch platforms. */
2619 #if (!GDB_MULTI_ARCH) && !defined (IN_SOLIB_CALL_TRAMPOLINE)
2620 #define IN_SOLIB_CALL_TRAMPOLINE(pc, name) (generic_in_solib_call_trampoline (pc, name))
2621 #endif
2622
2623 typedef int (gdbarch_in_solib_call_trampoline_ftype) (CORE_ADDR pc, char *name);
2624 extern int gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name);
2625 extern void set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline);
2626 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (IN_SOLIB_CALL_TRAMPOLINE)
2627 #error "Non multi-arch definition of IN_SOLIB_CALL_TRAMPOLINE"
2628 #endif
2629 #if GDB_MULTI_ARCH
2630 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (IN_SOLIB_CALL_TRAMPOLINE)
2631 #define IN_SOLIB_CALL_TRAMPOLINE(pc, name) (gdbarch_in_solib_call_trampoline (current_gdbarch, pc, name))
2632 #endif
2633 #endif
2634
2635 /* Some systems also have trampoline code for returning from shared libs. */
2636
2637 /* Default (function) for non- multi-arch platforms. */
2638 #if (!GDB_MULTI_ARCH) && !defined (IN_SOLIB_RETURN_TRAMPOLINE)
2639 #define IN_SOLIB_RETURN_TRAMPOLINE(pc, name) (generic_in_solib_return_trampoline (pc, name))
2640 #endif
2641
2642 typedef int (gdbarch_in_solib_return_trampoline_ftype) (CORE_ADDR pc, char *name);
2643 extern int gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name);
2644 extern void set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline);
2645 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (IN_SOLIB_RETURN_TRAMPOLINE)
2646 #error "Non multi-arch definition of IN_SOLIB_RETURN_TRAMPOLINE"
2647 #endif
2648 #if GDB_MULTI_ARCH
2649 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (IN_SOLIB_RETURN_TRAMPOLINE)
2650 #define IN_SOLIB_RETURN_TRAMPOLINE(pc, name) (gdbarch_in_solib_return_trampoline (current_gdbarch, pc, name))
2651 #endif
2652 #endif
2653
2654 /* Sigtramp is a routine that the kernel calls (which then calls the
2655    signal handler).  On most machines it is a library routine that is
2656    linked into the executable.
2657
2658    This macro, given a program counter value and the name of the
2659    function in which that PC resides (which can be null if the name is
2660    not known), returns nonzero if the PC and name show that we are in
2661    sigtramp.
2662
2663    On most machines just see if the name is sigtramp (and if we have
2664    no name, assume we are not in sigtramp).
2665
2666    FIXME: cagney/2002-04-21: The function find_pc_partial_function
2667    calls find_pc_sect_partial_function() which calls PC_IN_SIGTRAMP.
2668    This means PC_IN_SIGTRAMP function can't be implemented by doing its
2669    own local NAME lookup.
2670
2671    FIXME: cagney/2002-04-21: PC_IN_SIGTRAMP is something of a mess.
2672    Some code also depends on SIGTRAMP_START and SIGTRAMP_END but other
2673    does not. */
2674
2675 /* Default (function) for non- multi-arch platforms. */
2676 #if (!GDB_MULTI_ARCH) && !defined (PC_IN_SIGTRAMP)
2677 #define PC_IN_SIGTRAMP(pc, name) (legacy_pc_in_sigtramp (pc, name))
2678 #endif
2679
2680 typedef int (gdbarch_pc_in_sigtramp_ftype) (CORE_ADDR pc, char *name);
2681 extern int gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name);
2682 extern void set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp);
2683 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (PC_IN_SIGTRAMP)
2684 #error "Non multi-arch definition of PC_IN_SIGTRAMP"
2685 #endif
2686 #if GDB_MULTI_ARCH
2687 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PC_IN_SIGTRAMP)
2688 #define PC_IN_SIGTRAMP(pc, name) (gdbarch_pc_in_sigtramp (current_gdbarch, pc, name))
2689 #endif
2690 #endif
2691
2692 #if defined (SIGTRAMP_START)
2693 /* Legacy for systems yet to multi-arch SIGTRAMP_START */
2694 #if !defined (SIGTRAMP_START_P)
2695 #define SIGTRAMP_START_P() (1)
2696 #endif
2697 #endif
2698
2699 /* Default predicate for non- multi-arch targets. */
2700 #if (!GDB_MULTI_ARCH) && !defined (SIGTRAMP_START_P)
2701 #define SIGTRAMP_START_P() (0)
2702 #endif
2703
2704 extern int gdbarch_sigtramp_start_p (struct gdbarch *gdbarch);
2705 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIGTRAMP_START_P)
2706 #error "Non multi-arch definition of SIGTRAMP_START"
2707 #endif
2708 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SIGTRAMP_START_P)
2709 #define SIGTRAMP_START_P() (gdbarch_sigtramp_start_p (current_gdbarch))
2710 #endif
2711
2712 /* Default (function) for non- multi-arch platforms. */
2713 #if (!GDB_MULTI_ARCH) && !defined (SIGTRAMP_START)
2714 #define SIGTRAMP_START(pc) (internal_error (__FILE__, __LINE__, "SIGTRAMP_START"), 0)
2715 #endif
2716
2717 typedef CORE_ADDR (gdbarch_sigtramp_start_ftype) (CORE_ADDR pc);
2718 extern CORE_ADDR gdbarch_sigtramp_start (struct gdbarch *gdbarch, CORE_ADDR pc);
2719 extern void set_gdbarch_sigtramp_start (struct gdbarch *gdbarch, gdbarch_sigtramp_start_ftype *sigtramp_start);
2720 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIGTRAMP_START)
2721 #error "Non multi-arch definition of SIGTRAMP_START"
2722 #endif
2723 #if GDB_MULTI_ARCH
2724 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SIGTRAMP_START)
2725 #define SIGTRAMP_START(pc) (gdbarch_sigtramp_start (current_gdbarch, pc))
2726 #endif
2727 #endif
2728
2729 #if defined (SIGTRAMP_END)
2730 /* Legacy for systems yet to multi-arch SIGTRAMP_END */
2731 #if !defined (SIGTRAMP_END_P)
2732 #define SIGTRAMP_END_P() (1)
2733 #endif
2734 #endif
2735
2736 /* Default predicate for non- multi-arch targets. */
2737 #if (!GDB_MULTI_ARCH) && !defined (SIGTRAMP_END_P)
2738 #define SIGTRAMP_END_P() (0)
2739 #endif
2740
2741 extern int gdbarch_sigtramp_end_p (struct gdbarch *gdbarch);
2742 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIGTRAMP_END_P)
2743 #error "Non multi-arch definition of SIGTRAMP_END"
2744 #endif
2745 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SIGTRAMP_END_P)
2746 #define SIGTRAMP_END_P() (gdbarch_sigtramp_end_p (current_gdbarch))
2747 #endif
2748
2749 /* Default (function) for non- multi-arch platforms. */
2750 #if (!GDB_MULTI_ARCH) && !defined (SIGTRAMP_END)
2751 #define SIGTRAMP_END(pc) (internal_error (__FILE__, __LINE__, "SIGTRAMP_END"), 0)
2752 #endif
2753
2754 typedef CORE_ADDR (gdbarch_sigtramp_end_ftype) (CORE_ADDR pc);
2755 extern CORE_ADDR gdbarch_sigtramp_end (struct gdbarch *gdbarch, CORE_ADDR pc);
2756 extern void set_gdbarch_sigtramp_end (struct gdbarch *gdbarch, gdbarch_sigtramp_end_ftype *sigtramp_end);
2757 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIGTRAMP_END)
2758 #error "Non multi-arch definition of SIGTRAMP_END"
2759 #endif
2760 #if GDB_MULTI_ARCH
2761 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SIGTRAMP_END)
2762 #define SIGTRAMP_END(pc) (gdbarch_sigtramp_end (current_gdbarch, pc))
2763 #endif
2764 #endif
2765
2766 /* A target might have problems with watchpoints as soon as the stack
2767    frame of the current function has been destroyed.  This mostly happens
2768    as the first action in a funtion's epilogue.  in_function_epilogue_p()
2769    is defined to return a non-zero value if either the given addr is one
2770    instruction after the stack destroying instruction up to the trailing
2771    return instruction or if we can figure out that the stack frame has
2772    already been invalidated regardless of the value of addr.  Targets
2773    which don't suffer from that problem could just let this functionality
2774    untouched. */
2775
2776 typedef int (gdbarch_in_function_epilogue_p_ftype) (struct gdbarch *gdbarch, CORE_ADDR addr);
2777 extern int gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr);
2778 extern void set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p);
2779
2780 /* Given a vector of command-line arguments, return a newly allocated
2781    string which, when passed to the create_inferior function, will be
2782    parsed (on Unix systems, by the shell) to yield the same vector.
2783    This function should call error() if the argument vector is not
2784    representable for this target or if this target does not support
2785    command-line arguments.
2786    ARGC is the number of elements in the vector.
2787    ARGV is an array of strings, one per argument. */
2788
2789 typedef char * (gdbarch_construct_inferior_arguments_ftype) (struct gdbarch *gdbarch, int argc, char **argv);
2790 extern char * gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv);
2791 extern void set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments);
2792
2793 #if defined (DWARF2_BUILD_FRAME_INFO)
2794 /* Legacy for systems yet to multi-arch DWARF2_BUILD_FRAME_INFO */
2795 #if !defined (DWARF2_BUILD_FRAME_INFO_P)
2796 #define DWARF2_BUILD_FRAME_INFO_P() (1)
2797 #endif
2798 #endif
2799
2800 /* Default predicate for non- multi-arch targets. */
2801 #if (!GDB_MULTI_ARCH) && !defined (DWARF2_BUILD_FRAME_INFO_P)
2802 #define DWARF2_BUILD_FRAME_INFO_P() (0)
2803 #endif
2804
2805 extern int gdbarch_dwarf2_build_frame_info_p (struct gdbarch *gdbarch);
2806 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DWARF2_BUILD_FRAME_INFO_P)
2807 #error "Non multi-arch definition of DWARF2_BUILD_FRAME_INFO"
2808 #endif
2809 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DWARF2_BUILD_FRAME_INFO_P)
2810 #define DWARF2_BUILD_FRAME_INFO_P() (gdbarch_dwarf2_build_frame_info_p (current_gdbarch))
2811 #endif
2812
2813 /* Default (function) for non- multi-arch platforms. */
2814 #if (!GDB_MULTI_ARCH) && !defined (DWARF2_BUILD_FRAME_INFO)
2815 #define DWARF2_BUILD_FRAME_INFO(objfile) (internal_error (__FILE__, __LINE__, "DWARF2_BUILD_FRAME_INFO"), 0)
2816 #endif
2817
2818 typedef void (gdbarch_dwarf2_build_frame_info_ftype) (struct objfile *objfile);
2819 extern void gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch, struct objfile *objfile);
2820 extern void set_gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch, gdbarch_dwarf2_build_frame_info_ftype *dwarf2_build_frame_info);
2821 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DWARF2_BUILD_FRAME_INFO)
2822 #error "Non multi-arch definition of DWARF2_BUILD_FRAME_INFO"
2823 #endif
2824 #if GDB_MULTI_ARCH
2825 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DWARF2_BUILD_FRAME_INFO)
2826 #define DWARF2_BUILD_FRAME_INFO(objfile) (gdbarch_dwarf2_build_frame_info (current_gdbarch, objfile))
2827 #endif
2828 #endif
2829
2830 /* Default (function) for non- multi-arch platforms. */
2831 #if (!GDB_MULTI_ARCH) && !defined (ELF_MAKE_MSYMBOL_SPECIAL)
2832 #define ELF_MAKE_MSYMBOL_SPECIAL(sym, msym) (default_elf_make_msymbol_special (sym, msym))
2833 #endif
2834
2835 typedef void (gdbarch_elf_make_msymbol_special_ftype) (asymbol *sym, struct minimal_symbol *msym);
2836 extern void gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym);
2837 extern void set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special);
2838 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (ELF_MAKE_MSYMBOL_SPECIAL)
2839 #error "Non multi-arch definition of ELF_MAKE_MSYMBOL_SPECIAL"
2840 #endif
2841 #if GDB_MULTI_ARCH
2842 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ELF_MAKE_MSYMBOL_SPECIAL)
2843 #define ELF_MAKE_MSYMBOL_SPECIAL(sym, msym) (gdbarch_elf_make_msymbol_special (current_gdbarch, sym, msym))
2844 #endif
2845 #endif
2846
2847 /* Default (function) for non- multi-arch platforms. */
2848 #if (!GDB_MULTI_ARCH) && !defined (COFF_MAKE_MSYMBOL_SPECIAL)
2849 #define COFF_MAKE_MSYMBOL_SPECIAL(val, msym) (default_coff_make_msymbol_special (val, msym))
2850 #endif
2851
2852 typedef void (gdbarch_coff_make_msymbol_special_ftype) (int val, struct minimal_symbol *msym);
2853 extern void gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym);
2854 extern void set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special);
2855 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (COFF_MAKE_MSYMBOL_SPECIAL)
2856 #error "Non multi-arch definition of COFF_MAKE_MSYMBOL_SPECIAL"
2857 #endif
2858 #if GDB_MULTI_ARCH
2859 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (COFF_MAKE_MSYMBOL_SPECIAL)
2860 #define COFF_MAKE_MSYMBOL_SPECIAL(val, msym) (gdbarch_coff_make_msymbol_special (current_gdbarch, val, msym))
2861 #endif
2862 #endif
2863
2864 /* Default (value) for non- multi-arch platforms. */
2865 #if (!GDB_MULTI_ARCH) && !defined (NAME_OF_MALLOC)
2866 #define NAME_OF_MALLOC ("malloc")
2867 #endif
2868
2869 extern const char * gdbarch_name_of_malloc (struct gdbarch *gdbarch);
2870 extern void set_gdbarch_name_of_malloc (struct gdbarch *gdbarch, const char * name_of_malloc);
2871 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (NAME_OF_MALLOC)
2872 #error "Non multi-arch definition of NAME_OF_MALLOC"
2873 #endif
2874 #if GDB_MULTI_ARCH
2875 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NAME_OF_MALLOC)
2876 #define NAME_OF_MALLOC (gdbarch_name_of_malloc (current_gdbarch))
2877 #endif
2878 #endif
2879
2880 /* Default (value) for non- multi-arch platforms. */
2881 #if (!GDB_MULTI_ARCH) && !defined (CANNOT_STEP_BREAKPOINT)
2882 #define CANNOT_STEP_BREAKPOINT (0)
2883 #endif
2884
2885 extern int gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch);
2886 extern void set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, int cannot_step_breakpoint);
2887 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CANNOT_STEP_BREAKPOINT)
2888 #error "Non multi-arch definition of CANNOT_STEP_BREAKPOINT"
2889 #endif
2890 #if GDB_MULTI_ARCH
2891 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CANNOT_STEP_BREAKPOINT)
2892 #define CANNOT_STEP_BREAKPOINT (gdbarch_cannot_step_breakpoint (current_gdbarch))
2893 #endif
2894 #endif
2895
2896 /* Default (value) for non- multi-arch platforms. */
2897 #if (!GDB_MULTI_ARCH) && !defined (HAVE_NONSTEPPABLE_WATCHPOINT)
2898 #define HAVE_NONSTEPPABLE_WATCHPOINT (0)
2899 #endif
2900
2901 extern int gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch);
2902 extern void set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, int have_nonsteppable_watchpoint);
2903 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (HAVE_NONSTEPPABLE_WATCHPOINT)
2904 #error "Non multi-arch definition of HAVE_NONSTEPPABLE_WATCHPOINT"
2905 #endif
2906 #if GDB_MULTI_ARCH
2907 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (HAVE_NONSTEPPABLE_WATCHPOINT)
2908 #define HAVE_NONSTEPPABLE_WATCHPOINT (gdbarch_have_nonsteppable_watchpoint (current_gdbarch))
2909 #endif
2910 #endif
2911
2912 #if defined (ADDRESS_CLASS_TYPE_FLAGS)
2913 /* Legacy for systems yet to multi-arch ADDRESS_CLASS_TYPE_FLAGS */
2914 #if !defined (ADDRESS_CLASS_TYPE_FLAGS_P)
2915 #define ADDRESS_CLASS_TYPE_FLAGS_P() (1)
2916 #endif
2917 #endif
2918
2919 /* Default predicate for non- multi-arch targets. */
2920 #if (!GDB_MULTI_ARCH) && !defined (ADDRESS_CLASS_TYPE_FLAGS_P)
2921 #define ADDRESS_CLASS_TYPE_FLAGS_P() (0)
2922 #endif
2923
2924 extern int gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch);
2925 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (ADDRESS_CLASS_TYPE_FLAGS_P)
2926 #error "Non multi-arch definition of ADDRESS_CLASS_TYPE_FLAGS"
2927 #endif
2928 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ADDRESS_CLASS_TYPE_FLAGS_P)
2929 #define ADDRESS_CLASS_TYPE_FLAGS_P() (gdbarch_address_class_type_flags_p (current_gdbarch))
2930 #endif
2931
2932 /* Default (function) for non- multi-arch platforms. */
2933 #if (!GDB_MULTI_ARCH) && !defined (ADDRESS_CLASS_TYPE_FLAGS)
2934 #define ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class) (internal_error (__FILE__, __LINE__, "ADDRESS_CLASS_TYPE_FLAGS"), 0)
2935 #endif
2936
2937 typedef int (gdbarch_address_class_type_flags_ftype) (int byte_size, int dwarf2_addr_class);
2938 extern int gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class);
2939 extern void set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags);
2940 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (ADDRESS_CLASS_TYPE_FLAGS)
2941 #error "Non multi-arch definition of ADDRESS_CLASS_TYPE_FLAGS"
2942 #endif
2943 #if GDB_MULTI_ARCH
2944 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ADDRESS_CLASS_TYPE_FLAGS)
2945 #define ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class) (gdbarch_address_class_type_flags (current_gdbarch, byte_size, dwarf2_addr_class))
2946 #endif
2947 #endif
2948
2949 extern int gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch);
2950
2951 typedef const char * (gdbarch_address_class_type_flags_to_name_ftype) (struct gdbarch *gdbarch, int type_flags);
2952 extern const char * gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags);
2953 extern void set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name);
2954
2955 extern int gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch);
2956
2957 typedef int (gdbarch_address_class_name_to_type_flags_ftype) (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
2958 extern int gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr);
2959 extern void set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags);
2960
2961 /* Is a register in a group */
2962
2963 typedef int (gdbarch_register_reggroup_p_ftype) (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
2964 extern int gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup);
2965 extern void set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p);
2966
2967 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
2968
2969
2970 /* Mechanism for co-ordinating the selection of a specific
2971    architecture.
2972
2973    GDB targets (*-tdep.c) can register an interest in a specific
2974    architecture.  Other GDB components can register a need to maintain
2975    per-architecture data.
2976
2977    The mechanisms below ensures that there is only a loose connection
2978    between the set-architecture command and the various GDB
2979    components.  Each component can independently register their need
2980    to maintain architecture specific data with gdbarch.
2981
2982    Pragmatics:
2983
2984    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
2985    didn't scale.
2986
2987    The more traditional mega-struct containing architecture specific
2988    data for all the various GDB components was also considered.  Since
2989    GDB is built from a variable number of (fairly independent)
2990    components it was determined that the global aproach was not
2991    applicable. */
2992
2993
2994 /* Register a new architectural family with GDB.
2995
2996    Register support for the specified ARCHITECTURE with GDB.  When
2997    gdbarch determines that the specified architecture has been
2998    selected, the corresponding INIT function is called.
2999
3000    --
3001
3002    The INIT function takes two parameters: INFO which contains the
3003    information available to gdbarch about the (possibly new)
3004    architecture; ARCHES which is a list of the previously created
3005    ``struct gdbarch'' for this architecture.
3006
3007    The INFO parameter is, as far as possible, be pre-initialized with
3008    information obtained from INFO.ABFD or the previously selected
3009    architecture.
3010
3011    The ARCHES parameter is a linked list (sorted most recently used)
3012    of all the previously created architures for this architecture
3013    family.  The (possibly NULL) ARCHES->gdbarch can used to access
3014    values from the previously selected architecture for this
3015    architecture family.  The global ``current_gdbarch'' shall not be
3016    used.
3017
3018    The INIT function shall return any of: NULL - indicating that it
3019    doesn't recognize the selected architecture; an existing ``struct
3020    gdbarch'' from the ARCHES list - indicating that the new
3021    architecture is just a synonym for an earlier architecture (see
3022    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
3023    - that describes the selected architecture (see gdbarch_alloc()).
3024
3025    The DUMP_TDEP function shall print out all target specific values.
3026    Care should be taken to ensure that the function works in both the
3027    multi-arch and non- multi-arch cases. */
3028
3029 struct gdbarch_list
3030 {
3031   struct gdbarch *gdbarch;
3032   struct gdbarch_list *next;
3033 };
3034
3035 struct gdbarch_info
3036 {
3037   /* Use default: NULL (ZERO). */
3038   const struct bfd_arch_info *bfd_arch_info;
3039
3040   /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO).  */
3041   int byte_order;
3042
3043   /* Use default: NULL (ZERO). */
3044   bfd *abfd;
3045
3046   /* Use default: NULL (ZERO). */
3047   struct gdbarch_tdep_info *tdep_info;
3048
3049   /* Use default: GDB_OSABI_UNINITIALIZED (-1).  */
3050   enum gdb_osabi osabi;
3051 };
3052
3053 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
3054 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
3055
3056 /* DEPRECATED - use gdbarch_register() */
3057 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
3058
3059 extern void gdbarch_register (enum bfd_architecture architecture,
3060                               gdbarch_init_ftype *,
3061                               gdbarch_dump_tdep_ftype *);
3062
3063
3064 /* Return a freshly allocated, NULL terminated, array of the valid
3065    architecture names.  Since architectures are registered during the
3066    _initialize phase this function only returns useful information
3067    once initialization has been completed. */
3068
3069 extern const char **gdbarch_printable_names (void);
3070
3071
3072 /* Helper function.  Search the list of ARCHES for a GDBARCH that
3073    matches the information provided by INFO. */
3074
3075 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
3076
3077
3078 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
3079    basic initialization using values obtained from the INFO andTDEP
3080    parameters.  set_gdbarch_*() functions are called to complete the
3081    initialization of the object. */
3082
3083 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
3084
3085
3086 /* Helper function.  Free a partially-constructed ``struct gdbarch''.
3087    It is assumed that the caller freeds the ``struct
3088    gdbarch_tdep''. */
3089
3090 extern void gdbarch_free (struct gdbarch *);
3091
3092
3093 /* Helper function. Force an update of the current architecture.
3094
3095    The actual architecture selected is determined by INFO, ``(gdb) set
3096    architecture'' et.al., the existing architecture and BFD's default
3097    architecture.  INFO should be initialized to zero and then selected
3098    fields should be updated.
3099
3100    Returns non-zero if the update succeeds */
3101
3102 extern int gdbarch_update_p (struct gdbarch_info info);
3103
3104
3105
3106 /* Register per-architecture data-pointer.
3107
3108    Reserve space for a per-architecture data-pointer.  An identifier
3109    for the reserved data-pointer is returned.  That identifer should
3110    be saved in a local static variable.
3111
3112    The per-architecture data-pointer is either initialized explicitly
3113    (set_gdbarch_data()) or implicitly (by INIT() via a call to
3114    gdbarch_data()).  FREE() is called to delete either an existing
3115    data-pointer overridden by set_gdbarch_data() or when the
3116    architecture object is being deleted.
3117
3118    When a previously created architecture is re-selected, the
3119    per-architecture data-pointer for that previous architecture is
3120    restored.  INIT() is not re-called.
3121
3122    Multiple registrarants for any architecture are allowed (and
3123    strongly encouraged).  */
3124
3125 struct gdbarch_data;
3126
3127 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
3128 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
3129                                         void *pointer);
3130 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
3131                                                    gdbarch_data_free_ftype *free);
3132 extern void set_gdbarch_data (struct gdbarch *gdbarch,
3133                               struct gdbarch_data *data,
3134                               void *pointer);
3135
3136 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
3137
3138
3139 /* Register per-architecture memory region.
3140
3141    Provide a memory-region swap mechanism.  Per-architecture memory
3142    region are created.  These memory regions are swapped whenever the
3143    architecture is changed.  For a new architecture, the memory region
3144    is initialized with zero (0) and the INIT function is called.
3145
3146    Memory regions are swapped / initialized in the order that they are
3147    registered.  NULL DATA and/or INIT values can be specified.
3148
3149    New code should use register_gdbarch_data(). */
3150
3151 typedef void (gdbarch_swap_ftype) (void);
3152 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
3153 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
3154
3155
3156
3157 /* The target-system-dependent byte order is dynamic */
3158
3159 extern int target_byte_order;
3160 #ifndef TARGET_BYTE_ORDER
3161 #define TARGET_BYTE_ORDER (target_byte_order + 0)
3162 #endif
3163
3164 extern int target_byte_order_auto;
3165 #ifndef TARGET_BYTE_ORDER_AUTO
3166 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
3167 #endif
3168
3169
3170
3171 /* The target-system-dependent BFD architecture is dynamic */
3172
3173 extern int target_architecture_auto;
3174 #ifndef TARGET_ARCHITECTURE_AUTO
3175 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
3176 #endif
3177
3178 extern const struct bfd_arch_info *target_architecture;
3179 #ifndef TARGET_ARCHITECTURE
3180 #define TARGET_ARCHITECTURE (target_architecture + 0)
3181 #endif
3182
3183
3184 /* The target-system-dependent disassembler is semi-dynamic */
3185
3186 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
3187                                 unsigned int len, disassemble_info *info);
3188
3189 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
3190                                   disassemble_info *info);
3191
3192 extern void dis_asm_print_address (bfd_vma addr,
3193                                    disassemble_info *info);
3194
3195 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
3196 extern disassemble_info tm_print_insn_info;
3197 #ifndef TARGET_PRINT_INSN_INFO
3198 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
3199 #endif
3200
3201
3202
3203 /* Set the dynamic target-system-dependent parameters (architecture,
3204    byte-order, ...) using information found in the BFD */
3205
3206 extern void set_gdbarch_from_file (bfd *);
3207
3208
3209 /* Initialize the current architecture to the "first" one we find on
3210    our list.  */
3211
3212 extern void initialize_current_architecture (void);
3213
3214 /* For non-multiarched targets, do any initialization of the default
3215    gdbarch object necessary after the _initialize_MODULE functions
3216    have run.  */
3217 extern void initialize_non_multiarch (void);
3218
3219 /* gdbarch trace variable */
3220 extern int gdbarch_debug;
3221
3222 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
3223
3224 #endif