gdb/gdbarch.h

   1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
   2
   3 /* Dynamic architecture support for GDB, the GNU debugger.
   4    Copyright 1998-1999, Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /* This file was created with the aid of ``gdbarch.sh''.
  24
  25    The bourn shell script ``gdbarch.sh'' creates the files
  26    ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
  27    against the existing ``gdbarch.[hc]''.  Any differences found
  28    being reported.
  29
  30    If editing this file, please also run gdbarch.sh and merge any
  31    changes into that script. Conversely, when makeing sweeping changes
  32    to this file, modifying gdbarch.sh and using its output may prove
  33    easier. */
  34
  35 #ifndef GDBARCH_H
  36 #define GDBARCH_H
  37
  38 struct frame_info;
  39 struct value;
  40
  41
  42 extern struct gdbarch *current_gdbarch;
  43
  44
  45 /* If any of the following are defined, the target wasn't correctly
  46    converted. */
  47
  48 #if GDB_MULTI_ARCH
  49 #if defined (EXTRA_FRAME_INFO)
  50 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
  51 #endif
  52 #endif
  53
  54 #if GDB_MULTI_ARCH
  55 #if defined (FRAME_FIND_SAVED_REGS)
  56 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
  57 #endif
  58 #endif
  59
  60
  61 /* The following are pre-initialized by GDBARCH. */
  62
  63 extern const struct bfd_arch_info * gdbarch_bfd_arch_info (struct gdbarch *gdbarch);
  64 /* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
  65 #if GDB_MULTI_ARCH
  66 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_ARCHITECTURE)
  67 #define TARGET_ARCHITECTURE (gdbarch_bfd_arch_info (current_gdbarch))
  68 #endif
  69 #endif
  70
  71 extern int gdbarch_byte_order (struct gdbarch *gdbarch);
  72 /* set_gdbarch_byte_order() - not applicable - pre-initialized. */
  73 #if GDB_MULTI_ARCH
  74 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_BYTE_ORDER)
  75 #define TARGET_BYTE_ORDER (gdbarch_byte_order (current_gdbarch))
  76 #endif
  77 #endif
  78
  79
  80 /* The following are initialized by the target dependant code. */
  81
  82 /* Number of bits in a char or unsigned char for the target machine.
  83    Just like CHAR_BIT in <limits.h> but describes the target machine.
  84    v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
  85
  86    Number of bits in a short or unsigned short for the target machine. */
  87
  88 /* Default (value) for non- multi-arch platforms. */
  89 #if (!GDB_MULTI_ARCH) && !defined (TARGET_SHORT_BIT)
  90 #define TARGET_SHORT_BIT (2*TARGET_CHAR_BIT)
  91 #endif
  92
  93 extern int gdbarch_short_bit (struct gdbarch *gdbarch);
  94 extern void set_gdbarch_short_bit (struct gdbarch *gdbarch, int short_bit);
  95 #if GDB_MULTI_ARCH
  96 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_SHORT_BIT)
  97 #define TARGET_SHORT_BIT (gdbarch_short_bit (current_gdbarch))
  98 #endif
  99 #endif
 100
 101 /* Number of bits in an int or unsigned int for the target machine. */
 102
 103 /* Default (value) for non- multi-arch platforms. */
 104 #if (!GDB_MULTI_ARCH) && !defined (TARGET_INT_BIT)
 105 #define TARGET_INT_BIT (4*TARGET_CHAR_BIT)
 106 #endif
 107
 108 extern int gdbarch_int_bit (struct gdbarch *gdbarch);
 109 extern void set_gdbarch_int_bit (struct gdbarch *gdbarch, int int_bit);
 110 #if GDB_MULTI_ARCH
 111 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_INT_BIT)
 112 #define TARGET_INT_BIT (gdbarch_int_bit (current_gdbarch))
 113 #endif
 114 #endif
 115
 116 /* Number of bits in a long or unsigned long for the target machine. */
 117
 118 /* Default (value) for non- multi-arch platforms. */
 119 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_BIT)
 120 #define TARGET_LONG_BIT (4*TARGET_CHAR_BIT)
 121 #endif
 122
 123 extern int gdbarch_long_bit (struct gdbarch *gdbarch);
 124 extern void set_gdbarch_long_bit (struct gdbarch *gdbarch, int long_bit);
 125 #if GDB_MULTI_ARCH
 126 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_BIT)
 127 #define TARGET_LONG_BIT (gdbarch_long_bit (current_gdbarch))
 128 #endif
 129 #endif
 130
 131 /* Number of bits in a long long or unsigned long long for the target
 132    machine. */
 133
 134 /* Default (value) for non- multi-arch platforms. */
 135 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_LONG_BIT)
 136 #define TARGET_LONG_LONG_BIT (2*TARGET_LONG_BIT)
 137 #endif
 138
 139 extern int gdbarch_long_long_bit (struct gdbarch *gdbarch);
 140 extern void set_gdbarch_long_long_bit (struct gdbarch *gdbarch, int long_long_bit);
 141 #if GDB_MULTI_ARCH
 142 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_LONG_BIT)
 143 #define TARGET_LONG_LONG_BIT (gdbarch_long_long_bit (current_gdbarch))
 144 #endif
 145 #endif
 146
 147 /* Number of bits in a float for the target machine. */
 148
 149 /* Default (value) for non- multi-arch platforms. */
 150 #if (!GDB_MULTI_ARCH) && !defined (TARGET_FLOAT_BIT)
 151 #define TARGET_FLOAT_BIT (4*TARGET_CHAR_BIT)
 152 #endif
 153
 154 extern int gdbarch_float_bit (struct gdbarch *gdbarch);
 155 extern void set_gdbarch_float_bit (struct gdbarch *gdbarch, int float_bit);
 156 #if GDB_MULTI_ARCH
 157 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_FLOAT_BIT)
 158 #define TARGET_FLOAT_BIT (gdbarch_float_bit (current_gdbarch))
 159 #endif
 160 #endif
 161
 162 /* Number of bits in a double for the target machine. */
 163
 164 /* Default (value) for non- multi-arch platforms. */
 165 #if (!GDB_MULTI_ARCH) && !defined (TARGET_DOUBLE_BIT)
 166 #define TARGET_DOUBLE_BIT (8*TARGET_CHAR_BIT)
 167 #endif
 168
 169 extern int gdbarch_double_bit (struct gdbarch *gdbarch);
 170 extern void set_gdbarch_double_bit (struct gdbarch *gdbarch, int double_bit);
 171 #if GDB_MULTI_ARCH
 172 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_DOUBLE_BIT)
 173 #define TARGET_DOUBLE_BIT (gdbarch_double_bit (current_gdbarch))
 174 #endif
 175 #endif
 176
 177 /* Number of bits in a long double for the target machine. */
 178
 179 /* Default (value) for non- multi-arch platforms. */
 180 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_DOUBLE_BIT)
 181 #define TARGET_LONG_DOUBLE_BIT (2*TARGET_DOUBLE_BIT)
 182 #endif
 183
 184 extern int gdbarch_long_double_bit (struct gdbarch *gdbarch);
 185 extern void set_gdbarch_long_double_bit (struct gdbarch *gdbarch, int long_double_bit);
 186 #if GDB_MULTI_ARCH
 187 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_DOUBLE_BIT)
 188 #define TARGET_LONG_DOUBLE_BIT (gdbarch_long_double_bit (current_gdbarch))
 189 #endif
 190 #endif
 191
 192 /* Number of bits in a pointer for the target machine */
 193
 194 /* Default (value) for non- multi-arch platforms. */
 195 #if (!GDB_MULTI_ARCH) && !defined (TARGET_PTR_BIT)
 196 #define TARGET_PTR_BIT (TARGET_INT_BIT)
 197 #endif
 198
 199 extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
 200 extern void set_gdbarch_ptr_bit (struct gdbarch *gdbarch, int ptr_bit);
 201 #if GDB_MULTI_ARCH
 202 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_PTR_BIT)
 203 #define TARGET_PTR_BIT (gdbarch_ptr_bit (current_gdbarch))
 204 #endif
 205 #endif
 206
 207 /* Number of bits in a BFD_VMA for the target object file format. */
 208
 209 /* Default (value) for non- multi-arch platforms. */
 210 #if (!GDB_MULTI_ARCH) && !defined (TARGET_BFD_VMA_BIT)
 211 #define TARGET_BFD_VMA_BIT (TARGET_ARCHITECTURE->bits_per_address)
 212 #endif
 213
 214 extern int gdbarch_bfd_vma_bit (struct gdbarch *gdbarch);
 215 extern void set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch, int bfd_vma_bit);
 216 #if GDB_MULTI_ARCH
 217 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_BFD_VMA_BIT)
 218 #define TARGET_BFD_VMA_BIT (gdbarch_bfd_vma_bit (current_gdbarch))
 219 #endif
 220 #endif
 221
 222 /* Default (value) for non- multi-arch platforms. */
 223 #if (!GDB_MULTI_ARCH) && !defined (IEEE_FLOAT)
 224 #define IEEE_FLOAT (0)
 225 #endif
 226
 227 extern int gdbarch_ieee_float (struct gdbarch *gdbarch);
 228 extern void set_gdbarch_ieee_float (struct gdbarch *gdbarch, int ieee_float);
 229 #if GDB_MULTI_ARCH
 230 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (IEEE_FLOAT)
 231 #define IEEE_FLOAT (gdbarch_ieee_float (current_gdbarch))
 232 #endif
 233 #endif
 234
 235 typedef CORE_ADDR (gdbarch_read_pc_ftype) (int pid);
 236 extern CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, int pid);
 237 extern void set_gdbarch_read_pc (struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc);
 238 #if GDB_MULTI_ARCH
 239 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_PC)
 240 #define TARGET_READ_PC(pid) (gdbarch_read_pc (current_gdbarch, pid))
 241 #endif
 242 #endif
 243
 244 typedef void (gdbarch_write_pc_ftype) (CORE_ADDR val, int pid);
 245 extern void gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid);
 246 extern void set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc);
 247 #if GDB_MULTI_ARCH
 248 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_WRITE_PC)
 249 #define TARGET_WRITE_PC(val, pid) (gdbarch_write_pc (current_gdbarch, val, pid))
 250 #endif
 251 #endif
 252
 253 typedef CORE_ADDR (gdbarch_read_fp_ftype) (void);
 254 extern CORE_ADDR gdbarch_read_fp (struct gdbarch *gdbarch);
 255 extern void set_gdbarch_read_fp (struct gdbarch *gdbarch, gdbarch_read_fp_ftype *read_fp);
 256 #if GDB_MULTI_ARCH
 257 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_FP)
 258 #define TARGET_READ_FP() (gdbarch_read_fp (current_gdbarch))
 259 #endif
 260 #endif
 261
 262 typedef void (gdbarch_write_fp_ftype) (CORE_ADDR val);
 263 extern void gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val);
 264 extern void set_gdbarch_write_fp (struct gdbarch *gdbarch, gdbarch_write_fp_ftype *write_fp);
 265 #if GDB_MULTI_ARCH
 266 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_WRITE_FP)
 267 #define TARGET_WRITE_FP(val) (gdbarch_write_fp (current_gdbarch, val))
 268 #endif
 269 #endif
 270
 271 typedef CORE_ADDR (gdbarch_read_sp_ftype) (void);
 272 extern CORE_ADDR gdbarch_read_sp (struct gdbarch *gdbarch);
 273 extern void set_gdbarch_read_sp (struct gdbarch *gdbarch, gdbarch_read_sp_ftype *read_sp);
 274 #if GDB_MULTI_ARCH
 275 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_READ_SP)
 276 #define TARGET_READ_SP() (gdbarch_read_sp (current_gdbarch))
 277 #endif
 278 #endif
 279
 280 typedef void (gdbarch_write_sp_ftype) (CORE_ADDR val);
 281 extern void gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val);
 282 extern void set_gdbarch_write_sp (struct gdbarch *gdbarch, gdbarch_write_sp_ftype *write_sp);
 283 #if GDB_MULTI_ARCH
 284 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_WRITE_SP)
 285 #define TARGET_WRITE_SP(val) (gdbarch_write_sp (current_gdbarch, val))
 286 #endif
 287 #endif
 288
 289 extern int gdbarch_num_regs (struct gdbarch *gdbarch);
 290 extern void set_gdbarch_num_regs (struct gdbarch *gdbarch, int num_regs);
 291 #if GDB_MULTI_ARCH
 292 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NUM_REGS)
 293 #define NUM_REGS (gdbarch_num_regs (current_gdbarch))
 294 #endif
 295 #endif
 296
 297 /* This macro gives the number of pseudo-registers that live in the
 298    register namespace but do not get fetched or stored on the target.
 299    These pseudo-registers may be aliases for other registers,
 300    combinations of other registers, or they may be computed by GDB. */
 301
 302 /* Default (value) for non- multi-arch platforms. */
 303 #if (!GDB_MULTI_ARCH) && !defined (NUM_PSEUDO_REGS)
 304 #define NUM_PSEUDO_REGS (0)
 305 #endif
 306
 307 extern int gdbarch_num_pseudo_regs (struct gdbarch *gdbarch);
 308 extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo_regs);
 309 #if GDB_MULTI_ARCH
 310 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NUM_PSEUDO_REGS)
 311 #define NUM_PSEUDO_REGS (gdbarch_num_pseudo_regs (current_gdbarch))
 312 #endif
 313 #endif
 314
 315 extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
 316 extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
 317 #if GDB_MULTI_ARCH
 318 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SP_REGNUM)
 319 #define SP_REGNUM (gdbarch_sp_regnum (current_gdbarch))
 320 #endif
 321 #endif
 322
 323 extern int gdbarch_fp_regnum (struct gdbarch *gdbarch);
 324 extern void set_gdbarch_fp_regnum (struct gdbarch *gdbarch, int fp_regnum);
 325 #if GDB_MULTI_ARCH
 326 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FP_REGNUM)
 327 #define FP_REGNUM (gdbarch_fp_regnum (current_gdbarch))
 328 #endif
 329 #endif
 330
 331 extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
 332 extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
 333 #if GDB_MULTI_ARCH
 334 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PC_REGNUM)
 335 #define PC_REGNUM (gdbarch_pc_regnum (current_gdbarch))
 336 #endif
 337 #endif
 338
 339 /* Default (value) for non- multi-arch platforms. */
 340 #if (!GDB_MULTI_ARCH) && !defined (FP0_REGNUM)
 341 #define FP0_REGNUM (-1)
 342 #endif
 343
 344 extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
 345 extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
 346 #if GDB_MULTI_ARCH
 347 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FP0_REGNUM)
 348 #define FP0_REGNUM (gdbarch_fp0_regnum (current_gdbarch))
 349 #endif
 350 #endif
 351
 352 /* Default (value) for non- multi-arch platforms. */
 353 #if (!GDB_MULTI_ARCH) && !defined (NPC_REGNUM)
 354 #define NPC_REGNUM (-1)
 355 #endif
 356
 357 extern int gdbarch_npc_regnum (struct gdbarch *gdbarch);
 358 extern void set_gdbarch_npc_regnum (struct gdbarch *gdbarch, int npc_regnum);
 359 #if GDB_MULTI_ARCH
 360 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NPC_REGNUM)
 361 #define NPC_REGNUM (gdbarch_npc_regnum (current_gdbarch))
 362 #endif
 363 #endif
 364
 365 /* Default (value) for non- multi-arch platforms. */
 366 #if (!GDB_MULTI_ARCH) && !defined (NNPC_REGNUM)
 367 #define NNPC_REGNUM (-1)
 368 #endif
 369
 370 extern int gdbarch_nnpc_regnum (struct gdbarch *gdbarch);
 371 extern void set_gdbarch_nnpc_regnum (struct gdbarch *gdbarch, int nnpc_regnum);
 372 #if GDB_MULTI_ARCH
 373 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (NNPC_REGNUM)
 374 #define NNPC_REGNUM (gdbarch_nnpc_regnum (current_gdbarch))
 375 #endif
 376 #endif
 377
 378 /* Default (function) for non- multi-arch platforms. */
 379 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_NAME)
 380 #define REGISTER_NAME(regnr) (legacy_register_name (regnr))
 381 #endif
 382
 383 typedef char * (gdbarch_register_name_ftype) (int regnr);
 384 extern char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
 385 extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
 386 #if GDB_MULTI_ARCH
 387 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_NAME)
 388 #define REGISTER_NAME(regnr) (gdbarch_register_name (current_gdbarch, regnr))
 389 #endif
 390 #endif
 391
 392 extern int gdbarch_register_size (struct gdbarch *gdbarch);
 393 extern void set_gdbarch_register_size (struct gdbarch *gdbarch, int register_size);
 394 #if GDB_MULTI_ARCH
 395 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_SIZE)
 396 #define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
 397 #endif
 398 #endif
 399
 400 extern int gdbarch_register_bytes (struct gdbarch *gdbarch);
 401 extern void set_gdbarch_register_bytes (struct gdbarch *gdbarch, int register_bytes);
 402 #if GDB_MULTI_ARCH
 403 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTES)
 404 #define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch))
 405 #endif
 406 #endif
 407
 408 typedef int (gdbarch_register_byte_ftype) (int reg_nr);
 409 extern int gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr);
 410 extern void set_gdbarch_register_byte (struct gdbarch *gdbarch, gdbarch_register_byte_ftype *register_byte);
 411 #if GDB_MULTI_ARCH
 412 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTE)
 413 #define REGISTER_BYTE(reg_nr) (gdbarch_register_byte (current_gdbarch, reg_nr))
 414 #endif
 415 #endif
 416
 417 typedef int (gdbarch_register_raw_size_ftype) (int reg_nr);
 418 extern int gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr);
 419 extern void set_gdbarch_register_raw_size (struct gdbarch *gdbarch, gdbarch_register_raw_size_ftype *register_raw_size);
 420 #if GDB_MULTI_ARCH
 421 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_RAW_SIZE)
 422 #define REGISTER_RAW_SIZE(reg_nr) (gdbarch_register_raw_size (current_gdbarch, reg_nr))
 423 #endif
 424 #endif
 425
 426 extern int gdbarch_max_register_raw_size (struct gdbarch *gdbarch);
 427 extern void set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch, int max_register_raw_size);
 428 #if GDB_MULTI_ARCH
 429 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MAX_REGISTER_RAW_SIZE)
 430 #define MAX_REGISTER_RAW_SIZE (gdbarch_max_register_raw_size (current_gdbarch))
 431 #endif
 432 #endif
 433
 434 typedef int (gdbarch_register_virtual_size_ftype) (int reg_nr);
 435 extern int gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr);
 436 extern void set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, gdbarch_register_virtual_size_ftype *register_virtual_size);
 437 #if GDB_MULTI_ARCH
 438 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_VIRTUAL_SIZE)
 439 #define REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_register_virtual_size (current_gdbarch, reg_nr))
 440 #endif
 441 #endif
 442
 443 extern int gdbarch_max_register_virtual_size (struct gdbarch *gdbarch);
 444 extern void set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch, int max_register_virtual_size);
 445 #if GDB_MULTI_ARCH
 446 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MAX_REGISTER_VIRTUAL_SIZE)
 447 #define MAX_REGISTER_VIRTUAL_SIZE (gdbarch_max_register_virtual_size (current_gdbarch))
 448 #endif
 449 #endif
 450
 451 typedef struct type * (gdbarch_register_virtual_type_ftype) (int reg_nr);
 452 extern struct type * gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr);
 453 extern void set_gdbarch_register_virtual_type (struct gdbarch *gdbarch, gdbarch_register_virtual_type_ftype *register_virtual_type);
 454 #if GDB_MULTI_ARCH
 455 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_VIRTUAL_TYPE)
 456 #define REGISTER_VIRTUAL_TYPE(reg_nr) (gdbarch_register_virtual_type (current_gdbarch, reg_nr))
 457 #endif
 458 #endif
 459
 460 /* Default (function) for non- multi-arch platforms. */
 461 #if (!GDB_MULTI_ARCH) && !defined (DO_REGISTERS_INFO)
 462 #define DO_REGISTERS_INFO(reg_nr, fpregs) (do_registers_info (reg_nr, fpregs))
 463 #endif
 464
 465 typedef void (gdbarch_do_registers_info_ftype) (int reg_nr, int fpregs);
 466 extern void gdbarch_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs);
 467 extern void set_gdbarch_do_registers_info (struct gdbarch *gdbarch, gdbarch_do_registers_info_ftype *do_registers_info);
 468 #if GDB_MULTI_ARCH
 469 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DO_REGISTERS_INFO)
 470 #define DO_REGISTERS_INFO(reg_nr, fpregs) (gdbarch_do_registers_info (current_gdbarch, reg_nr, fpregs))
 471 #endif
 472 #endif
 473
 474 /* MAP a GDB RAW register number onto a simulator register number.  See
 475    also include/...-sim.h. */
 476
 477 /* Default (function) for non- multi-arch platforms. */
 478 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_SIM_REGNO)
 479 #define REGISTER_SIM_REGNO(reg_nr) (default_register_sim_regno (reg_nr))
 480 #endif
 481
 482 typedef int (gdbarch_register_sim_regno_ftype) (int reg_nr);
 483 extern int gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr);
 484 extern void set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno);
 485 #if GDB_MULTI_ARCH
 486 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_SIM_REGNO)
 487 #define REGISTER_SIM_REGNO(reg_nr) (gdbarch_register_sim_regno (current_gdbarch, reg_nr))
 488 #endif
 489 #endif
 490
 491 extern int gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch);
 492 extern void set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch, int use_generic_dummy_frames);
 493 #if GDB_MULTI_ARCH
 494 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (USE_GENERIC_DUMMY_FRAMES)
 495 #define USE_GENERIC_DUMMY_FRAMES (gdbarch_use_generic_dummy_frames (current_gdbarch))
 496 #endif
 497 #endif
 498
 499 extern int gdbarch_call_dummy_location (struct gdbarch *gdbarch);
 500 extern void set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, int call_dummy_location);
 501 #if GDB_MULTI_ARCH
 502 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_LOCATION)
 503 #define CALL_DUMMY_LOCATION (gdbarch_call_dummy_location (current_gdbarch))
 504 #endif
 505 #endif
 506
 507 typedef CORE_ADDR (gdbarch_call_dummy_address_ftype) (void);
 508 extern CORE_ADDR gdbarch_call_dummy_address (struct gdbarch *gdbarch);
 509 extern void set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, gdbarch_call_dummy_address_ftype *call_dummy_address);
 510 #if GDB_MULTI_ARCH
 511 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_ADDRESS)
 512 #define CALL_DUMMY_ADDRESS() (gdbarch_call_dummy_address (current_gdbarch))
 513 #endif
 514 #endif
 515
 516 extern CORE_ADDR gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch);
 517 extern void set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_start_offset);
 518 #if GDB_MULTI_ARCH
 519 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_START_OFFSET)
 520 #define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
 521 #endif
 522 #endif
 523
 524 extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
 525 extern void set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_breakpoint_offset);
 526 #if GDB_MULTI_ARCH
 527 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
 528 #define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
 529 #endif
 530 #endif
 531
 532 extern int gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch);
 533 extern void set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch, int call_dummy_breakpoint_offset_p);
 534 #if GDB_MULTI_ARCH
 535 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET_P)
 536 #define CALL_DUMMY_BREAKPOINT_OFFSET_P (gdbarch_call_dummy_breakpoint_offset_p (current_gdbarch))
 537 #endif
 538 #endif
 539
 540 extern int gdbarch_call_dummy_length (struct gdbarch *gdbarch);
 541 extern void set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, int call_dummy_length);
 542 #if GDB_MULTI_ARCH
 543 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_LENGTH)
 544 #define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
 545 #endif
 546 #endif
 547
 548 typedef int (gdbarch_pc_in_call_dummy_ftype) (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address);
 549 extern int gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address);
 550 extern void set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy);
 551 #if GDB_MULTI_ARCH
 552 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PC_IN_CALL_DUMMY)
 553 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) (gdbarch_pc_in_call_dummy (current_gdbarch, pc, sp, frame_address))
 554 #endif
 555 #endif
 556
 557 extern int gdbarch_call_dummy_p (struct gdbarch *gdbarch);
 558 extern void set_gdbarch_call_dummy_p (struct gdbarch *gdbarch, int call_dummy_p);
 559 #if GDB_MULTI_ARCH
 560 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_P)
 561 #define CALL_DUMMY_P (gdbarch_call_dummy_p (current_gdbarch))
 562 #endif
 563 #endif
 564
 565 /* Default (value) for non- multi-arch platforms. */
 566 #if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_WORDS)
 567 #define CALL_DUMMY_WORDS (legacy_call_dummy_words)
 568 #endif
 569
 570 extern LONGEST * gdbarch_call_dummy_words (struct gdbarch *gdbarch);
 571 extern void set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, LONGEST * call_dummy_words);
 572 #if GDB_MULTI_ARCH
 573 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_WORDS)
 574 #define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
 575 #endif
 576 #endif
 577
 578 /* Default (value) for non- multi-arch platforms. */
 579 #if (!GDB_MULTI_ARCH) && !defined (SIZEOF_CALL_DUMMY_WORDS)
 580 #define SIZEOF_CALL_DUMMY_WORDS (legacy_sizeof_call_dummy_words)
 581 #endif
 582
 583 extern int gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch);
 584 extern void set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, int sizeof_call_dummy_words);
 585 #if GDB_MULTI_ARCH
 586 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SIZEOF_CALL_DUMMY_WORDS)
 587 #define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
 588 #endif
 589 #endif
 590
 591 extern int gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch);
 592 extern void set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch, int call_dummy_stack_adjust_p);
 593 #if GDB_MULTI_ARCH
 594 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_STACK_ADJUST_P)
 595 #define CALL_DUMMY_STACK_ADJUST_P (gdbarch_call_dummy_stack_adjust_p (current_gdbarch))
 596 #endif
 597 #endif
 598
 599 extern int gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch);
 600 extern void set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch, int call_dummy_stack_adjust);
 601 #if GDB_MULTI_ARCH
 602 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (CALL_DUMMY_STACK_ADJUST)
 603 #define CALL_DUMMY_STACK_ADJUST (gdbarch_call_dummy_stack_adjust (current_gdbarch))
 604 #endif
 605 #endif
 606
 607 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);
 608 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);
 609 extern void set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_fix_call_dummy_ftype *fix_call_dummy);
 610 #if GDB_MULTI_ARCH
 611 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FIX_CALL_DUMMY)
 612 #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))
 613 #endif
 614 #endif
 615
 616 extern int gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch);
 617 extern void set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, int believe_pcc_promotion);
 618 #if GDB_MULTI_ARCH
 619 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (BELIEVE_PCC_PROMOTION)
 620 #define BELIEVE_PCC_PROMOTION (gdbarch_believe_pcc_promotion (current_gdbarch))
 621 #endif
 622 #endif
 623
 624 extern int gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch);
 625 extern void set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch, int believe_pcc_promotion_type);
 626 #if GDB_MULTI_ARCH
 627 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (BELIEVE_PCC_PROMOTION_TYPE)
 628 #define BELIEVE_PCC_PROMOTION_TYPE (gdbarch_believe_pcc_promotion_type (current_gdbarch))
 629 #endif
 630 #endif
 631
 632 /* Default (function) for non- multi-arch platforms. */
 633 #if (!GDB_MULTI_ARCH) && !defined (COERCE_FLOAT_TO_DOUBLE)
 634 #define COERCE_FLOAT_TO_DOUBLE(formal, actual) (default_coerce_float_to_double (formal, actual))
 635 #endif
 636
 637 typedef int (gdbarch_coerce_float_to_double_ftype) (struct type *formal, struct type *actual);
 638 extern int gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual);
 639 extern void set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, gdbarch_coerce_float_to_double_ftype *coerce_float_to_double);
 640 #if GDB_MULTI_ARCH
 641 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (COERCE_FLOAT_TO_DOUBLE)
 642 #define COERCE_FLOAT_TO_DOUBLE(formal, actual) (gdbarch_coerce_float_to_double (current_gdbarch, formal, actual))
 643 #endif
 644 #endif
 645
 646 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);
 647 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);
 648 extern void set_gdbarch_get_saved_register (struct gdbarch *gdbarch, gdbarch_get_saved_register_ftype *get_saved_register);
 649 #if GDB_MULTI_ARCH
 650 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (GET_SAVED_REGISTER)
 651 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) (gdbarch_get_saved_register (current_gdbarch, raw_buffer, optimized, addrp, frame, regnum, lval))
 652 #endif
 653 #endif
 654
 655 /* Default (function) for non- multi-arch platforms. */
 656 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_CONVERTIBLE)
 657 #define REGISTER_CONVERTIBLE(nr) (generic_register_convertible_not (nr))
 658 #endif
 659
 660 typedef int (gdbarch_register_convertible_ftype) (int nr);
 661 extern int gdbarch_register_convertible (struct gdbarch *gdbarch, int nr);
 662 extern void set_gdbarch_register_convertible (struct gdbarch *gdbarch, gdbarch_register_convertible_ftype *register_convertible);
 663 #if GDB_MULTI_ARCH
 664 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_CONVERTIBLE)
 665 #define REGISTER_CONVERTIBLE(nr) (gdbarch_register_convertible (current_gdbarch, nr))
 666 #endif
 667 #endif
 668
 669 /* Default (function) for non- multi-arch platforms. */
 670 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_CONVERT_TO_VIRTUAL)
 671 #define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (internal_error ("REGISTER_CONVERT_TO_VIRTUAL"), 0)
 672 #endif
 673
 674 typedef void (gdbarch_register_convert_to_virtual_ftype) (int regnum, struct type *type, char *from, char *to);
 675 extern void gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to);
 676 extern void set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual);
 677 #if GDB_MULTI_ARCH
 678 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_CONVERT_TO_VIRTUAL)
 679 #define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (gdbarch_register_convert_to_virtual (current_gdbarch, regnum, type, from, to))
 680 #endif
 681 #endif
 682
 683 /* Default (function) for non- multi-arch platforms. */
 684 #if (!GDB_MULTI_ARCH) && !defined (REGISTER_CONVERT_TO_RAW)
 685 #define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (internal_error ("REGISTER_CONVERT_TO_RAW"), 0)
 686 #endif
 687
 688 typedef void (gdbarch_register_convert_to_raw_ftype) (struct type *type, int regnum, char *from, char *to);
 689 extern void gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to);
 690 extern void set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, gdbarch_register_convert_to_raw_ftype *register_convert_to_raw);
 691 #if GDB_MULTI_ARCH
 692 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_CONVERT_TO_RAW)
 693 #define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (gdbarch_register_convert_to_raw (current_gdbarch, type, regnum, from, to))
 694 #endif
 695 #endif
 696
 697 /* This function is called when the value of a pseudo-register needs to
 698    be updated.  Typically it will be defined on a per-architecture
 699    basis. */
 700
 701 /* Default (function) for non- multi-arch platforms. */
 702 #if (!GDB_MULTI_ARCH) && !defined (FETCH_PSEUDO_REGISTER)
 703 #define FETCH_PSEUDO_REGISTER(regnum) (internal_error ("FETCH_PSEUDO_REGISTER"), 0)
 704 #endif
 705
 706 typedef void (gdbarch_fetch_pseudo_register_ftype) (int regnum);
 707 extern void gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch, int regnum);
 708 extern void set_gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch, gdbarch_fetch_pseudo_register_ftype *fetch_pseudo_register);
 709 #if GDB_MULTI_ARCH
 710 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FETCH_PSEUDO_REGISTER)
 711 #define FETCH_PSEUDO_REGISTER(regnum) (gdbarch_fetch_pseudo_register (current_gdbarch, regnum))
 712 #endif
 713 #endif
 714
 715 /* This function is called when the value of a pseudo-register needs to
 716    be set or stored.  Typically it will be defined on a
 717    per-architecture basis. */
 718
 719 /* Default (function) for non- multi-arch platforms. */
 720 #if (!GDB_MULTI_ARCH) && !defined (STORE_PSEUDO_REGISTER)
 721 #define STORE_PSEUDO_REGISTER(regnum) (internal_error ("STORE_PSEUDO_REGISTER"), 0)
 722 #endif
 723
 724 typedef void (gdbarch_store_pseudo_register_ftype) (int regnum);
 725 extern void gdbarch_store_pseudo_register (struct gdbarch *gdbarch, int regnum);
 726 extern void set_gdbarch_store_pseudo_register (struct gdbarch *gdbarch, gdbarch_store_pseudo_register_ftype *store_pseudo_register);
 727 #if GDB_MULTI_ARCH
 728 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STORE_PSEUDO_REGISTER)
 729 #define STORE_PSEUDO_REGISTER(regnum) (gdbarch_store_pseudo_register (current_gdbarch, regnum))
 730 #endif
 731 #endif
 732
 733 /* Default (function) for non- multi-arch platforms. */
 734 #if (!GDB_MULTI_ARCH) && !defined (POINTER_TO_ADDRESS)
 735 #define POINTER_TO_ADDRESS(type, buf) (unsigned_pointer_to_address (type, buf))
 736 #endif
 737
 738 typedef CORE_ADDR (gdbarch_pointer_to_address_ftype) (struct type *type, void *buf);
 739 extern CORE_ADDR gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf);
 740 extern void set_gdbarch_pointer_to_address (struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address);
 741 #if GDB_MULTI_ARCH
 742 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (POINTER_TO_ADDRESS)
 743 #define POINTER_TO_ADDRESS(type, buf) (gdbarch_pointer_to_address (current_gdbarch, type, buf))
 744 #endif
 745 #endif
 746
 747 /* Default (function) for non- multi-arch platforms. */
 748 #if (!GDB_MULTI_ARCH) && !defined (ADDRESS_TO_POINTER)
 749 #define ADDRESS_TO_POINTER(type, buf, addr) (unsigned_address_to_pointer (type, buf, addr))
 750 #endif
 751
 752 typedef void (gdbarch_address_to_pointer_ftype) (struct type *type, void *buf, CORE_ADDR addr);
 753 extern void gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr);
 754 extern void set_gdbarch_address_to_pointer (struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer);
 755 #if GDB_MULTI_ARCH
 756 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (ADDRESS_TO_POINTER)
 757 #define ADDRESS_TO_POINTER(type, buf, addr) (gdbarch_address_to_pointer (current_gdbarch, type, buf, addr))
 758 #endif
 759 #endif
 760
 761 /* Default (function) for non- multi-arch platforms. */
 762 #if (!GDB_MULTI_ARCH) && !defined (RETURN_VALUE_ON_STACK)
 763 #define RETURN_VALUE_ON_STACK(type) (generic_return_value_on_stack_not (type))
 764 #endif
 765
 766 typedef int (gdbarch_return_value_on_stack_ftype) (struct type *type);
 767 extern int gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type);
 768 extern void set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch, gdbarch_return_value_on_stack_ftype *return_value_on_stack);
 769 #if GDB_MULTI_ARCH
 770 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (RETURN_VALUE_ON_STACK)
 771 #define RETURN_VALUE_ON_STACK(type) (gdbarch_return_value_on_stack (current_gdbarch, type))
 772 #endif
 773 #endif
 774
 775 typedef void (gdbarch_extract_return_value_ftype) (struct type *type, char *regbuf, char *valbuf);
 776 extern void gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf);
 777 extern void set_gdbarch_extract_return_value (struct gdbarch *gdbarch, gdbarch_extract_return_value_ftype *extract_return_value);
 778 #if GDB_MULTI_ARCH
 779 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_RETURN_VALUE)
 780 #define EXTRACT_RETURN_VALUE(type, regbuf, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regbuf, valbuf))
 781 #endif
 782 #endif
 783
 784 typedef CORE_ADDR (gdbarch_push_arguments_ftype) (int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
 785 extern CORE_ADDR gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr);
 786 extern void set_gdbarch_push_arguments (struct gdbarch *gdbarch, gdbarch_push_arguments_ftype *push_arguments);
 787 #if GDB_MULTI_ARCH
 788 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PUSH_ARGUMENTS)
 789 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) (gdbarch_push_arguments (current_gdbarch, nargs, args, sp, struct_return, struct_addr))
 790 #endif
 791 #endif
 792
 793 typedef void (gdbarch_push_dummy_frame_ftype) (void);
 794 extern void gdbarch_push_dummy_frame (struct gdbarch *gdbarch);
 795 extern void set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch, gdbarch_push_dummy_frame_ftype *push_dummy_frame);
 796 #if GDB_MULTI_ARCH
 797 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PUSH_DUMMY_FRAME)
 798 #define PUSH_DUMMY_FRAME (gdbarch_push_dummy_frame (current_gdbarch))
 799 #endif
 800 #endif
 801
 802 typedef CORE_ADDR (gdbarch_push_return_address_ftype) (CORE_ADDR pc, CORE_ADDR sp);
 803 extern CORE_ADDR gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp);
 804 extern void set_gdbarch_push_return_address (struct gdbarch *gdbarch, gdbarch_push_return_address_ftype *push_return_address);
 805 #if GDB_MULTI_ARCH
 806 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PUSH_RETURN_ADDRESS)
 807 #define PUSH_RETURN_ADDRESS(pc, sp) (gdbarch_push_return_address (current_gdbarch, pc, sp))
 808 #endif
 809 #endif
 810
 811 typedef void (gdbarch_pop_frame_ftype) (void);
 812 extern void gdbarch_pop_frame (struct gdbarch *gdbarch);
 813 extern void set_gdbarch_pop_frame (struct gdbarch *gdbarch, gdbarch_pop_frame_ftype *pop_frame);
 814 #if GDB_MULTI_ARCH
 815 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (POP_FRAME)
 816 #define POP_FRAME (gdbarch_pop_frame (current_gdbarch))
 817 #endif
 818 #endif
 819
 820 /* I wish that these would just go away.... */
 821
 822 /* Default (function) for non- multi-arch platforms. */
 823 #if (!GDB_MULTI_ARCH) && !defined (D10V_MAKE_DADDR)
 824 #define D10V_MAKE_DADDR(x) (internal_error ("D10V_MAKE_DADDR"), 0)
 825 #endif
 826
 827 typedef CORE_ADDR (gdbarch_d10v_make_daddr_ftype) (CORE_ADDR x);
 828 extern CORE_ADDR gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x);
 829 extern void set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, gdbarch_d10v_make_daddr_ftype *d10v_make_daddr);
 830 #if GDB_MULTI_ARCH
 831 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_MAKE_DADDR)
 832 #define D10V_MAKE_DADDR(x) (gdbarch_d10v_make_daddr (current_gdbarch, x))
 833 #endif
 834 #endif
 835
 836 /* Default (function) for non- multi-arch platforms. */
 837 #if (!GDB_MULTI_ARCH) && !defined (D10V_MAKE_IADDR)
 838 #define D10V_MAKE_IADDR(x) (internal_error ("D10V_MAKE_IADDR"), 0)
 839 #endif
 840
 841 typedef CORE_ADDR (gdbarch_d10v_make_iaddr_ftype) (CORE_ADDR x);
 842 extern CORE_ADDR gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x);
 843 extern void set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr);
 844 #if GDB_MULTI_ARCH
 845 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_MAKE_IADDR)
 846 #define D10V_MAKE_IADDR(x) (gdbarch_d10v_make_iaddr (current_gdbarch, x))
 847 #endif
 848 #endif
 849
 850 /* Default (function) for non- multi-arch platforms. */
 851 #if (!GDB_MULTI_ARCH) && !defined (D10V_DADDR_P)
 852 #define D10V_DADDR_P(x) (internal_error ("D10V_DADDR_P"), 0)
 853 #endif
 854
 855 typedef int (gdbarch_d10v_daddr_p_ftype) (CORE_ADDR x);
 856 extern int gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x);
 857 extern void set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, gdbarch_d10v_daddr_p_ftype *d10v_daddr_p);
 858 #if GDB_MULTI_ARCH
 859 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_DADDR_P)
 860 #define D10V_DADDR_P(x) (gdbarch_d10v_daddr_p (current_gdbarch, x))
 861 #endif
 862 #endif
 863
 864 /* Default (function) for non- multi-arch platforms. */
 865 #if (!GDB_MULTI_ARCH) && !defined (D10V_IADDR_P)
 866 #define D10V_IADDR_P(x) (internal_error ("D10V_IADDR_P"), 0)
 867 #endif
 868
 869 typedef int (gdbarch_d10v_iaddr_p_ftype) (CORE_ADDR x);
 870 extern int gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x);
 871 extern void set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p);
 872 #if GDB_MULTI_ARCH
 873 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_IADDR_P)
 874 #define D10V_IADDR_P(x) (gdbarch_d10v_iaddr_p (current_gdbarch, x))
 875 #endif
 876 #endif
 877
 878 /* Default (function) for non- multi-arch platforms. */
 879 #if (!GDB_MULTI_ARCH) && !defined (D10V_CONVERT_DADDR_TO_RAW)
 880 #define D10V_CONVERT_DADDR_TO_RAW(x) (internal_error ("D10V_CONVERT_DADDR_TO_RAW"), 0)
 881 #endif
 882
 883 typedef CORE_ADDR (gdbarch_d10v_convert_daddr_to_raw_ftype) (CORE_ADDR x);
 884 extern CORE_ADDR gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x);
 885 extern void set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw);
 886 #if GDB_MULTI_ARCH
 887 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_CONVERT_DADDR_TO_RAW)
 888 #define D10V_CONVERT_DADDR_TO_RAW(x) (gdbarch_d10v_convert_daddr_to_raw (current_gdbarch, x))
 889 #endif
 890 #endif
 891
 892 /* Default (function) for non- multi-arch platforms. */
 893 #if (!GDB_MULTI_ARCH) && !defined (D10V_CONVERT_IADDR_TO_RAW)
 894 #define D10V_CONVERT_IADDR_TO_RAW(x) (internal_error ("D10V_CONVERT_IADDR_TO_RAW"), 0)
 895 #endif
 896
 897 typedef CORE_ADDR (gdbarch_d10v_convert_iaddr_to_raw_ftype) (CORE_ADDR x);
 898 extern CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x);
 899 extern void set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw);
 900 #if GDB_MULTI_ARCH
 901 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (D10V_CONVERT_IADDR_TO_RAW)
 902 #define D10V_CONVERT_IADDR_TO_RAW(x) (gdbarch_d10v_convert_iaddr_to_raw (current_gdbarch, x))
 903 #endif
 904 #endif
 905
 906 typedef void (gdbarch_store_struct_return_ftype) (CORE_ADDR addr, CORE_ADDR sp);
 907 extern void gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp);
 908 extern void set_gdbarch_store_struct_return (struct gdbarch *gdbarch, gdbarch_store_struct_return_ftype *store_struct_return);
 909 #if GDB_MULTI_ARCH
 910 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STORE_STRUCT_RETURN)
 911 #define STORE_STRUCT_RETURN(addr, sp) (gdbarch_store_struct_return (current_gdbarch, addr, sp))
 912 #endif
 913 #endif
 914
 915 typedef void (gdbarch_store_return_value_ftype) (struct type *type, char *valbuf);
 916 extern void gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf);
 917 extern void set_gdbarch_store_return_value (struct gdbarch *gdbarch, gdbarch_store_return_value_ftype *store_return_value);
 918 #if GDB_MULTI_ARCH
 919 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STORE_RETURN_VALUE)
 920 #define STORE_RETURN_VALUE(type, valbuf) (gdbarch_store_return_value (current_gdbarch, type, valbuf))
 921 #endif
 922 #endif
 923
 924 typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) (char *regbuf);
 925 extern CORE_ADDR gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf);
 926 extern void set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, gdbarch_extract_struct_value_address_ftype *extract_struct_value_address);
 927 #if GDB_MULTI_ARCH
 928 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
 929 #define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (gdbarch_extract_struct_value_address (current_gdbarch, regbuf))
 930 #endif
 931 #endif
 932
 933 typedef int (gdbarch_use_struct_convention_ftype) (int gcc_p, struct type *value_type);
 934 extern int gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type);
 935 extern void set_gdbarch_use_struct_convention (struct gdbarch *gdbarch, gdbarch_use_struct_convention_ftype *use_struct_convention);
 936 #if GDB_MULTI_ARCH
 937 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (USE_STRUCT_CONVENTION)
 938 #define USE_STRUCT_CONVENTION(gcc_p, value_type) (gdbarch_use_struct_convention (current_gdbarch, gcc_p, value_type))
 939 #endif
 940 #endif
 941
 942 typedef void (gdbarch_frame_init_saved_regs_ftype) (struct frame_info *frame);
 943 extern void gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame);
 944 extern void set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs);
 945 #if GDB_MULTI_ARCH
 946 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_INIT_SAVED_REGS)
 947 #define FRAME_INIT_SAVED_REGS(frame) (gdbarch_frame_init_saved_regs (current_gdbarch, frame))
 948 #endif
 949 #endif
 950
 951 typedef void (gdbarch_init_extra_frame_info_ftype) (int fromleaf, struct frame_info *frame);
 952 extern void gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame);
 953 extern void set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, gdbarch_init_extra_frame_info_ftype *init_extra_frame_info);
 954 #if GDB_MULTI_ARCH
 955 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (INIT_EXTRA_FRAME_INFO)
 956 #define INIT_EXTRA_FRAME_INFO(fromleaf, frame) (gdbarch_init_extra_frame_info (current_gdbarch, fromleaf, frame))
 957 #endif
 958 #endif
 959
 960 typedef CORE_ADDR (gdbarch_skip_prologue_ftype) (CORE_ADDR ip);
 961 extern CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip);
 962 extern void set_gdbarch_skip_prologue (struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue);
 963 #if GDB_MULTI_ARCH
 964 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SKIP_PROLOGUE)
 965 #define SKIP_PROLOGUE(ip) (gdbarch_skip_prologue (current_gdbarch, ip))
 966 #endif
 967 #endif
 968
 969 /* Default (function) for non- multi-arch platforms. */
 970 #if (!GDB_MULTI_ARCH) && !defined (PROLOGUE_FRAMELESS_P)
 971 #define PROLOGUE_FRAMELESS_P(ip) (generic_prologue_frameless_p (ip))
 972 #endif
 973
 974 typedef int (gdbarch_prologue_frameless_p_ftype) (CORE_ADDR ip);
 975 extern int gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip);
 976 extern void set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, gdbarch_prologue_frameless_p_ftype *prologue_frameless_p);
 977 #if GDB_MULTI_ARCH
 978 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (PROLOGUE_FRAMELESS_P)
 979 #define PROLOGUE_FRAMELESS_P(ip) (gdbarch_prologue_frameless_p (current_gdbarch, ip))
 980 #endif
 981 #endif
 982
 983 typedef int (gdbarch_inner_than_ftype) (CORE_ADDR lhs, CORE_ADDR rhs);
 984 extern int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs);
 985 extern void set_gdbarch_inner_than (struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than);
 986 #if GDB_MULTI_ARCH
 987 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (INNER_THAN)
 988 #define INNER_THAN(lhs, rhs) (gdbarch_inner_than (current_gdbarch, lhs, rhs))
 989 #endif
 990 #endif
 991
 992 /* Default (function) for non- multi-arch platforms. */
 993 #if (!GDB_MULTI_ARCH) && !defined (BREAKPOINT_FROM_PC)
 994 #define BREAKPOINT_FROM_PC(pcptr, lenptr) (legacy_breakpoint_from_pc (pcptr, lenptr))
 995 #endif
 996
 997 typedef unsigned char * (gdbarch_breakpoint_from_pc_ftype) (CORE_ADDR *pcptr, int *lenptr);
 998 extern unsigned char * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr);
 999 extern void set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc);
1000 #if GDB_MULTI_ARCH
1001 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (BREAKPOINT_FROM_PC)
1002 #define BREAKPOINT_FROM_PC(pcptr, lenptr) (gdbarch_breakpoint_from_pc (current_gdbarch, pcptr, lenptr))
1003 #endif
1004 #endif
1005
1006 /* Default (function) for non- multi-arch platforms. */
1007 #if (!GDB_MULTI_ARCH) && !defined (MEMORY_INSERT_BREAKPOINT)
1008 #define MEMORY_INSERT_BREAKPOINT(addr, contents_cache) (default_memory_insert_breakpoint (addr, contents_cache))
1009 #endif
1010
1011 typedef int (gdbarch_memory_insert_breakpoint_ftype) (CORE_ADDR addr, char *contents_cache);
1012 extern int gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache);
1013 extern void set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint);
1014 #if GDB_MULTI_ARCH
1015 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MEMORY_INSERT_BREAKPOINT)
1016 #define MEMORY_INSERT_BREAKPOINT(addr, contents_cache) (gdbarch_memory_insert_breakpoint (current_gdbarch, addr, contents_cache))
1017 #endif
1018 #endif
1019
1020 /* Default (function) for non- multi-arch platforms. */
1021 #if (!GDB_MULTI_ARCH) && !defined (MEMORY_REMOVE_BREAKPOINT)
1022 #define MEMORY_REMOVE_BREAKPOINT(addr, contents_cache) (default_memory_remove_breakpoint (addr, contents_cache))
1023 #endif
1024
1025 typedef int (gdbarch_memory_remove_breakpoint_ftype) (CORE_ADDR addr, char *contents_cache);
1026 extern int gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache);
1027 extern void set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint);
1028 #if GDB_MULTI_ARCH
1029 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (MEMORY_REMOVE_BREAKPOINT)
1030 #define MEMORY_REMOVE_BREAKPOINT(addr, contents_cache) (gdbarch_memory_remove_breakpoint (current_gdbarch, addr, contents_cache))
1031 #endif
1032 #endif
1033
1034 extern CORE_ADDR gdbarch_decr_pc_after_break (struct gdbarch *gdbarch);
1035 extern void set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break);
1036 #if GDB_MULTI_ARCH
1037 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DECR_PC_AFTER_BREAK)
1038 #define DECR_PC_AFTER_BREAK (gdbarch_decr_pc_after_break (current_gdbarch))
1039 #endif
1040 #endif
1041
1042 extern CORE_ADDR gdbarch_function_start_offset (struct gdbarch *gdbarch);
1043 extern void set_gdbarch_function_start_offset (struct gdbarch *gdbarch, CORE_ADDR function_start_offset);
1044 #if GDB_MULTI_ARCH
1045 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FUNCTION_START_OFFSET)
1046 #define FUNCTION_START_OFFSET (gdbarch_function_start_offset (current_gdbarch))
1047 #endif
1048 #endif
1049
1050 /* Default (function) for non- multi-arch platforms. */
1051 #if (!GDB_MULTI_ARCH) && !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
1052 #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))
1053 #endif
1054
1055 typedef void (gdbarch_remote_translate_xfer_address_ftype) (CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
1056 extern void gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len);
1057 extern void set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address);
1058 #if GDB_MULTI_ARCH
1059 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
1060 #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))
1061 #endif
1062 #endif
1063
1064 extern CORE_ADDR gdbarch_frame_args_skip (struct gdbarch *gdbarch);
1065 extern void set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, CORE_ADDR frame_args_skip);
1066 #if GDB_MULTI_ARCH
1067 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_ARGS_SKIP)
1068 #define FRAME_ARGS_SKIP (gdbarch_frame_args_skip (current_gdbarch))
1069 #endif
1070 #endif
1071
1072 /* Default (function) for non- multi-arch platforms. */
1073 #if (!GDB_MULTI_ARCH) && !defined (FRAMELESS_FUNCTION_INVOCATION)
1074 #define FRAMELESS_FUNCTION_INVOCATION(fi) (generic_frameless_function_invocation_not (fi))
1075 #endif
1076
1077 typedef int (gdbarch_frameless_function_invocation_ftype) (struct frame_info *fi);
1078 extern int gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi);
1079 extern void set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, gdbarch_frameless_function_invocation_ftype *frameless_function_invocation);
1080 #if GDB_MULTI_ARCH
1081 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAMELESS_FUNCTION_INVOCATION)
1082 #define FRAMELESS_FUNCTION_INVOCATION(fi) (gdbarch_frameless_function_invocation (current_gdbarch, fi))
1083 #endif
1084 #endif
1085
1086 typedef CORE_ADDR (gdbarch_frame_chain_ftype) (struct frame_info *frame);
1087 extern CORE_ADDR gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame);
1088 extern void set_gdbarch_frame_chain (struct gdbarch *gdbarch, gdbarch_frame_chain_ftype *frame_chain);
1089 #if GDB_MULTI_ARCH
1090 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN)
1091 #define FRAME_CHAIN(frame) (gdbarch_frame_chain (current_gdbarch, frame))
1092 #endif
1093 #endif
1094
1095 typedef int (gdbarch_frame_chain_valid_ftype) (CORE_ADDR chain, struct frame_info *thisframe);
1096 extern int gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe);
1097 extern void set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch, gdbarch_frame_chain_valid_ftype *frame_chain_valid);
1098 #if GDB_MULTI_ARCH
1099 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_VALID)
1100 #define FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_frame_chain_valid (current_gdbarch, chain, thisframe))
1101 #endif
1102 #endif
1103
1104 typedef CORE_ADDR (gdbarch_frame_saved_pc_ftype) (struct frame_info *fi);
1105 extern CORE_ADDR gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi);
1106 extern void set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch, gdbarch_frame_saved_pc_ftype *frame_saved_pc);
1107 #if GDB_MULTI_ARCH
1108 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_SAVED_PC)
1109 #define FRAME_SAVED_PC(fi) (gdbarch_frame_saved_pc (current_gdbarch, fi))
1110 #endif
1111 #endif
1112
1113 typedef CORE_ADDR (gdbarch_frame_args_address_ftype) (struct frame_info *fi);
1114 extern CORE_ADDR gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi);
1115 extern void set_gdbarch_frame_args_address (struct gdbarch *gdbarch, gdbarch_frame_args_address_ftype *frame_args_address);
1116 #if GDB_MULTI_ARCH
1117 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_ARGS_ADDRESS)
1118 #define FRAME_ARGS_ADDRESS(fi) (gdbarch_frame_args_address (current_gdbarch, fi))
1119 #endif
1120 #endif
1121
1122 typedef CORE_ADDR (gdbarch_frame_locals_address_ftype) (struct frame_info *fi);
1123 extern CORE_ADDR gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi);
1124 extern void set_gdbarch_frame_locals_address (struct gdbarch *gdbarch, gdbarch_frame_locals_address_ftype *frame_locals_address);
1125 #if GDB_MULTI_ARCH
1126 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_LOCALS_ADDRESS)
1127 #define FRAME_LOCALS_ADDRESS(fi) (gdbarch_frame_locals_address (current_gdbarch, fi))
1128 #endif
1129 #endif
1130
1131 typedef CORE_ADDR (gdbarch_saved_pc_after_call_ftype) (struct frame_info *frame);
1132 extern CORE_ADDR gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame);
1133 extern void set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, gdbarch_saved_pc_after_call_ftype *saved_pc_after_call);
1134 #if GDB_MULTI_ARCH
1135 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SAVED_PC_AFTER_CALL)
1136 #define SAVED_PC_AFTER_CALL(frame) (gdbarch_saved_pc_after_call (current_gdbarch, frame))
1137 #endif
1138 #endif
1139
1140 typedef int (gdbarch_frame_num_args_ftype) (struct frame_info *frame);
1141 extern int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame);
1142 extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args);
1143 #if GDB_MULTI_ARCH
1144 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_NUM_ARGS)
1145 #define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame))
1146 #endif
1147 #endif
1148
1149 #if defined (STACK_ALIGN)
1150 /* Legacy for systems yet to multi-arch STACK_ALIGN */
1151 #define STACK_ALIGN_P() (1)
1152 #endif
1153
1154 /* Default predicate for non- multi-arch targets. */
1155 #if (!GDB_MULTI_ARCH) && !defined (STACK_ALIGN_P)
1156 #define STACK_ALIGN_P() (0)
1157 #endif
1158
1159 extern int gdbarch_stack_align_p (struct gdbarch *gdbarch);
1160 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STACK_ALIGN_P)
1161 #define STACK_ALIGN_P() (gdbarch_stack_align_p (current_gdbarch))
1162 #endif
1163
1164 /* Default (function) for non- multi-arch platforms. */
1165 #if (!GDB_MULTI_ARCH) && !defined (STACK_ALIGN)
1166 #define STACK_ALIGN(sp) (internal_error ("STACK_ALIGN"), 0)
1167 #endif
1168
1169 typedef CORE_ADDR (gdbarch_stack_align_ftype) (CORE_ADDR sp);
1170 extern CORE_ADDR gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp);
1171 extern void set_gdbarch_stack_align (struct gdbarch *gdbarch, gdbarch_stack_align_ftype *stack_align);
1172 #if GDB_MULTI_ARCH
1173 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STACK_ALIGN)
1174 #define STACK_ALIGN(sp) (gdbarch_stack_align (current_gdbarch, sp))
1175 #endif
1176 #endif
1177
1178 /* Default (value) for non- multi-arch platforms. */
1179 #if (!GDB_MULTI_ARCH) && !defined (EXTRA_STACK_ALIGNMENT_NEEDED)
1180 #define EXTRA_STACK_ALIGNMENT_NEEDED (1)
1181 #endif
1182
1183 extern int gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch);
1184 extern void set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch, int extra_stack_alignment_needed);
1185 #if GDB_MULTI_ARCH
1186 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRA_STACK_ALIGNMENT_NEEDED)
1187 #define EXTRA_STACK_ALIGNMENT_NEEDED (gdbarch_extra_stack_alignment_needed (current_gdbarch))
1188 #endif
1189 #endif
1190
1191 #if defined (REG_STRUCT_HAS_ADDR)
1192 /* Legacy for systems yet to multi-arch REG_STRUCT_HAS_ADDR */
1193 #define REG_STRUCT_HAS_ADDR_P() (1)
1194 #endif
1195
1196 /* Default predicate for non- multi-arch targets. */
1197 #if (!GDB_MULTI_ARCH) && !defined (REG_STRUCT_HAS_ADDR_P)
1198 #define REG_STRUCT_HAS_ADDR_P() (0)
1199 #endif
1200
1201 extern int gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch);
1202 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REG_STRUCT_HAS_ADDR_P)
1203 #define REG_STRUCT_HAS_ADDR_P() (gdbarch_reg_struct_has_addr_p (current_gdbarch))
1204 #endif
1205
1206 /* Default (function) for non- multi-arch platforms. */
1207 #if (!GDB_MULTI_ARCH) && !defined (REG_STRUCT_HAS_ADDR)
1208 #define REG_STRUCT_HAS_ADDR(gcc_p, type) (internal_error ("REG_STRUCT_HAS_ADDR"), 0)
1209 #endif
1210
1211 typedef int (gdbarch_reg_struct_has_addr_ftype) (int gcc_p, struct type *type);
1212 extern int gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type);
1213 extern void set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr);
1214 #if GDB_MULTI_ARCH
1215 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REG_STRUCT_HAS_ADDR)
1216 #define REG_STRUCT_HAS_ADDR(gcc_p, type) (gdbarch_reg_struct_has_addr (current_gdbarch, gcc_p, type))
1217 #endif
1218 #endif
1219
1220 #if defined (SAVE_DUMMY_FRAME_TOS)
1221 /* Legacy for systems yet to multi-arch SAVE_DUMMY_FRAME_TOS */
1222 #define SAVE_DUMMY_FRAME_TOS_P() (1)
1223 #endif
1224
1225 /* Default predicate for non- multi-arch targets. */
1226 #if (!GDB_MULTI_ARCH) && !defined (SAVE_DUMMY_FRAME_TOS_P)
1227 #define SAVE_DUMMY_FRAME_TOS_P() (0)
1228 #endif
1229
1230 extern int gdbarch_save_dummy_frame_tos_p (struct gdbarch *gdbarch);
1231 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SAVE_DUMMY_FRAME_TOS_P)
1232 #define SAVE_DUMMY_FRAME_TOS_P() (gdbarch_save_dummy_frame_tos_p (current_gdbarch))
1233 #endif
1234
1235 /* Default (function) for non- multi-arch platforms. */
1236 #if (!GDB_MULTI_ARCH) && !defined (SAVE_DUMMY_FRAME_TOS)
1237 #define SAVE_DUMMY_FRAME_TOS(sp) (internal_error ("SAVE_DUMMY_FRAME_TOS"), 0)
1238 #endif
1239
1240 typedef void (gdbarch_save_dummy_frame_tos_ftype) (CORE_ADDR sp);
1241 extern void gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp);
1242 extern void set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos);
1243 #if GDB_MULTI_ARCH
1244 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (SAVE_DUMMY_FRAME_TOS)
1245 #define SAVE_DUMMY_FRAME_TOS(sp) (gdbarch_save_dummy_frame_tos (current_gdbarch, sp))
1246 #endif
1247 #endif
1248
1249 /* Default (value) for non- multi-arch platforms. */
1250 #if (!GDB_MULTI_ARCH) && !defined (TARGET_FLOAT_FORMAT)
1251 #define TARGET_FLOAT_FORMAT (default_float_format (current_gdbarch))
1252 #endif
1253
1254 extern const struct floatformat * gdbarch_float_format (struct gdbarch *gdbarch);
1255 extern void set_gdbarch_float_format (struct gdbarch *gdbarch, const struct floatformat * float_format);
1256 #if GDB_MULTI_ARCH
1257 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_FLOAT_FORMAT)
1258 #define TARGET_FLOAT_FORMAT (gdbarch_float_format (current_gdbarch))
1259 #endif
1260 #endif
1261
1262 /* Default (value) for non- multi-arch platforms. */
1263 #if (!GDB_MULTI_ARCH) && !defined (TARGET_DOUBLE_FORMAT)
1264 #define TARGET_DOUBLE_FORMAT (default_double_format (current_gdbarch))
1265 #endif
1266
1267 extern const struct floatformat * gdbarch_double_format (struct gdbarch *gdbarch);
1268 extern void set_gdbarch_double_format (struct gdbarch *gdbarch, const struct floatformat * double_format);
1269 #if GDB_MULTI_ARCH
1270 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_DOUBLE_FORMAT)
1271 #define TARGET_DOUBLE_FORMAT (gdbarch_double_format (current_gdbarch))
1272 #endif
1273 #endif
1274
1275 /* Default (value) for non- multi-arch platforms. */
1276 #if (!GDB_MULTI_ARCH) && !defined (TARGET_LONG_DOUBLE_FORMAT)
1277 #define TARGET_LONG_DOUBLE_FORMAT (&floatformat_unknown)
1278 #endif
1279
1280 extern const struct floatformat * gdbarch_long_double_format (struct gdbarch *gdbarch);
1281 extern void set_gdbarch_long_double_format (struct gdbarch *gdbarch, const struct floatformat * long_double_format);
1282 #if GDB_MULTI_ARCH
1283 #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (TARGET_LONG_DOUBLE_FORMAT)
1284 #define TARGET_LONG_DOUBLE_FORMAT (gdbarch_long_double_format (current_gdbarch))
1285 #endif
1286 #endif
1287
1288 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
1289
1290
1291 /* Mechanism for co-ordinating the selection of a specific
1292    architecture.
1293
1294    GDB targets (*-tdep.c) can register an interest in a specific
1295    architecture.  Other GDB components can register a need to maintain
1296    per-architecture data.
1297
1298    The mechanisms below ensures that there is only a loose connection
1299    between the set-architecture command and the various GDB
1300    components.  Each component can independantly register their need
1301    to maintain architecture specific data with gdbarch.
1302
1303    Pragmatics:
1304
1305    Previously, a single TARGET_ARCHITECTURE_HOOK was provided.  It
1306    didn't scale.
1307
1308    The more traditional mega-struct containing architecture specific
1309    data for all the various GDB components was also considered.  Since
1310    GDB is built from a variable number of (fairly independant)
1311    components it was determined that the global aproach was not
1312    applicable. */
1313
1314
1315 /* Register a new architectural family with GDB.
1316
1317    Register support for the specified ARCHITECTURE with GDB.  When
1318    gdbarch determines that the specified architecture has been
1319    selected, the corresponding INIT function is called.
1320
1321    --
1322
1323    The INIT function takes two parameters: INFO which contains the
1324    information available to gdbarch about the (possibly new)
1325    architecture; ARCHES which is a list of the previously created
1326    ``struct gdbarch'' for this architecture.
1327
1328    The INIT function parameter INFO shall, as far as possible, be
1329    pre-initialized with information obtained from INFO.ABFD or
1330    previously selected architecture (if similar).  INIT shall ensure
1331    that the INFO.BYTE_ORDER is non-zero.
1332
1333    The INIT function shall return any of: NULL - indicating that it
1334    doesn't reconize the selected architecture; an existing ``struct
1335    gdbarch'' from the ARCHES list - indicating that the new
1336    architecture is just a synonym for an earlier architecture (see
1337    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
1338    - that describes the selected architecture (see gdbarch_alloc()).
1339
1340    The DUMP_TDEP function shall print out all target specific values.
1341    Care should be taken to ensure that the function works in both the
1342    multi-arch and non- multi-arch cases. */
1343
1344 struct gdbarch_list
1345 {
1346   struct gdbarch *gdbarch;
1347   struct gdbarch_list *next;
1348 };
1349
1350 struct gdbarch_info
1351 {
1352   /* Use default: bfd_arch_unknown (ZERO). */
1353   enum bfd_architecture bfd_architecture;
1354
1355   /* Use default: NULL (ZERO). */
1356   const struct bfd_arch_info *bfd_arch_info;
1357
1358   /* Use default: 0 (ZERO). */
1359   int byte_order;
1360
1361   /* Use default: NULL (ZERO). */
1362   bfd *abfd;
1363
1364   /* Use default: NULL (ZERO). */
1365   struct gdbarch_tdep_info *tdep_info;
1366 };
1367
1368 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1369 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1370
1371 /* DEPRECATED - use gdbarch_register() */
1372 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1373
1374 extern void gdbarch_register (enum bfd_architecture architecture,
1375                               gdbarch_init_ftype *,
1376                               gdbarch_dump_tdep_ftype *);
1377
1378
1379 /* Return a freshly allocated, NULL terminated, array of the valid
1380    architecture names.  Since architectures are registered during the
1381    _initialize phase this function only returns useful information
1382    once initialization has been completed. */
1383
1384 extern const char **gdbarch_printable_names (void);
1385
1386
1387 /* Helper function.  Search the list of ARCHES for a GDBARCH that
1388    matches the information provided by INFO. */
1389
1390 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches,  const struct gdbarch_info *info);
1391
1392
1393 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
1394    basic initialization using values obtained from the INFO andTDEP
1395    parameters.  set_gdbarch_*() functions are called to complete the
1396    initialization of the object. */
1397
1398 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1399
1400
1401 /* Helper function.  Free a partially-constructed ``struct gdbarch''.
1402    It is assumed that the caller freeds the ``struct
1403    gdbarch_tdep''. */
1404
1405 extern void gdbarch_free (struct gdbarch *);
1406
1407
1408 /* Helper function. Force an update of the current architecture.  Used
1409    by legacy targets that have added their own target specific
1410    architecture manipulation commands.
1411
1412    The INFO parameter shall be fully initialized (``memset (&INFO,
1413    sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
1414    is called.  gdbarch_update_p() shall initialize any ``default''
1415    fields using information obtained from the previous architecture or
1416    INFO.ABFD (if specified) before calling the corresponding
1417    architectures INIT function.
1418
1419    Returns non-zero if the update succeeds */
1420
1421 extern int gdbarch_update_p (struct gdbarch_info info);
1422
1423
1424
1425 /* Register per-architecture data-pointer.
1426
1427    Reserve space for a per-architecture data-pointer.  An identifier
1428    for the reserved data-pointer is returned.  That identifer should
1429    be saved in a local static.
1430
1431    When a new architecture is selected, INIT() is called.  When a
1432    previous architecture is re-selected, the per-architecture
1433    data-pointer for that previous architecture is restored (INIT() is
1434    not called).
1435
1436    INIT() shall return the initial value for the per-architecture
1437    data-pointer for the current architecture.
1438
1439    Multiple registrarants for any architecture are allowed (and
1440    strongly encouraged).  */
1441
1442 typedef void *(gdbarch_data_ftype) (void);
1443 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
1444
1445 /* Return the value of the per-architecture data-pointer for the
1446    current architecture. */
1447
1448 extern void *gdbarch_data (struct gdbarch_data*);
1449
1450
1451
1452 /* Register per-architecture memory region.
1453
1454    Provide a memory-region swap mechanism.  Per-architecture memory
1455    region are created.  These memory regions are swapped whenever the
1456    architecture is changed.  For a new architecture, the memory region
1457    is initialized with zero (0) and the INIT function is called.
1458
1459    Memory regions are swapped / initialized in the order that they are
1460    registered.  NULL DATA and/or INIT values can be specified.
1461
1462    New code should use register_gdbarch_data(). */
1463
1464 typedef void (gdbarch_swap_ftype) (void);
1465 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
1466 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
1467
1468
1469
1470 /* The target-system-dependant byte order is dynamic */
1471
1472 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
1473    is selectable at runtime.  The user can use the ``set endian''
1474    command to change it.  TARGET_BYTE_ORDER_AUTO is nonzero when
1475    target_byte_order should be auto-detected (from the program image
1476    say). */
1477
1478 #if GDB_MULTI_ARCH
1479 /* Multi-arch GDB is always bi-endian. */
1480 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
1481 #endif
1482
1483 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
1484 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
1485    when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
1486 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1487 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
1488 #else
1489 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
1490 #endif
1491 #endif
1492
1493 extern int target_byte_order;
1494 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1495 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
1496    and expect defs.h to re-define TARGET_BYTE_ORDER. */
1497 #undef TARGET_BYTE_ORDER
1498 #endif
1499 #ifndef TARGET_BYTE_ORDER
1500 #define TARGET_BYTE_ORDER (target_byte_order + 0)
1501 #endif
1502
1503 extern int target_byte_order_auto;
1504 #ifndef TARGET_BYTE_ORDER_AUTO
1505 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1506 #endif
1507
1508
1509
1510 /* The target-system-dependant BFD architecture is dynamic */
1511
1512 extern int target_architecture_auto;
1513 #ifndef TARGET_ARCHITECTURE_AUTO
1514 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1515 #endif
1516
1517 extern const struct bfd_arch_info *target_architecture;
1518 #ifndef TARGET_ARCHITECTURE
1519 #define TARGET_ARCHITECTURE (target_architecture + 0)
1520 #endif
1521
1522
1523 /* The target-system-dependant disassembler is semi-dynamic */
1524
1525 #include "dis-asm.h"            /* Get defs for disassemble_info */
1526
1527 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
1528                                 unsigned int len, disassemble_info *info);
1529
1530 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1531                                   disassemble_info *info);
1532
1533 extern void dis_asm_print_address (bfd_vma addr,
1534                                    disassemble_info *info);
1535
1536 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1537 extern disassemble_info tm_print_insn_info;
1538 #ifndef TARGET_PRINT_INSN
1539 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
1540 #endif
1541 #ifndef TARGET_PRINT_INSN_INFO
1542 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1543 #endif
1544
1545
1546
1547 /* Explicit test for D10V architecture.
1548    USE of these macro's is *STRONGLY* discouraged. */
1549
1550 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
1551
1552
1553 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
1554 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
1555 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
1556 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
1557 #else
1558 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
1559 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
1560 #endif
1561 #endif
1562
1563
1564 /* Set the dynamic target-system-dependant parameters (architecture,
1565    byte-order, ...) using information found in the BFD */
1566
1567 extern void set_gdbarch_from_file (bfd *);
1568
1569
1570 /* Initialize the current architecture to the "first" one we find on
1571    our list.  */
1572
1573 extern void initialize_current_architecture (void);
1574
1575
1576 /* gdbarch trace variable */
1577 extern int gdbarch_debug;
1578
1579 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1580
1581 #endif