gdb/ia64-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2    Copyright 1999, 2000
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "symfile.h"            /* for entry_point_address */
  25 #include "gdbcore.h"
  26 #include "floatformat.h"
  27
  28 #include "objfiles.h"
  29 #include "elf/common.h"         /* for DT_PLTGOT value */
  30
  31 typedef enum instruction_type
  32 {
  33   A,                    /* Integer ALU ;    I-unit or M-unit */
  34   I,                    /* Non-ALU integer; I-unit */
  35   M,                    /* Memory ;         M-unit */
  36   F,                    /* Floating-point ; F-unit */
  37   B,                    /* Branch ;         B-unit */
  38   L,                    /* Extended (L+X) ; I-unit */
  39   X,                    /* Extended (L+X) ; I-unit */
  40   undefined             /* undefined or reserved */
  41 } instruction_type;
  42
  43 /* We represent IA-64 PC addresses as the value of the instruction
  44    pointer or'd with some bit combination in the low nibble which
  45    represents the slot number in the bundle addressed by the
  46    instruction pointer.  The problem is that the Linux kernel
  47    multiplies its slot numbers (for exceptions) by one while the
  48    disassembler multiplies its slot numbers by 6.  In addition, I've
  49    heard it said that the simulator uses 1 as the multiplier.
  50
  51    I've fixed the disassembler so that the bytes_per_line field will
  52    be the slot multiplier.  If bytes_per_line comes in as zero, it
  53    is set to six (which is how it was set up initially). -- objdump
  54    displays pretty disassembly dumps with this value.  For our purposes,
  55    we'll set bytes_per_line to SLOT_MULTIPLIER. This is okay since we
  56    never want to also display the raw bytes the way objdump does. */
  57
  58 #define SLOT_MULTIPLIER 1
  59
  60 /* Length in bytes of an instruction bundle */
  61
  62 #define BUNDLE_LEN 16
  63
  64 extern void _initialize_ia64_tdep (void);
  65
  66 static gdbarch_init_ftype ia64_gdbarch_init;
  67
  68 static gdbarch_register_name_ftype ia64_register_name;
  69 static gdbarch_register_raw_size_ftype ia64_register_raw_size;
  70 static gdbarch_register_virtual_size_ftype ia64_register_virtual_size;
  71 static gdbarch_register_virtual_type_ftype ia64_register_virtual_type;
  72 static gdbarch_register_byte_ftype ia64_register_byte;
  73 static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc;
  74 static gdbarch_frame_chain_ftype ia64_frame_chain;
  75 static gdbarch_frame_saved_pc_ftype ia64_frame_saved_pc;
  76 static gdbarch_skip_prologue_ftype ia64_skip_prologue;
  77 static gdbarch_frame_init_saved_regs_ftype ia64_frame_init_saved_regs;
  78 static gdbarch_get_saved_register_ftype ia64_get_saved_register;
  79 static gdbarch_extract_return_value_ftype ia64_extract_return_value;
  80 static gdbarch_extract_struct_value_address_ftype ia64_extract_struct_value_address;
  81 static gdbarch_use_struct_convention_ftype ia64_use_struct_convention;
  82 static gdbarch_frameless_function_invocation_ftype ia64_frameless_function_invocation;
  83 static gdbarch_init_extra_frame_info_ftype ia64_init_extra_frame_info;
  84 static gdbarch_store_return_value_ftype ia64_store_return_value;
  85 static gdbarch_store_struct_return_ftype ia64_store_struct_return;
  86 static gdbarch_push_arguments_ftype ia64_push_arguments;
  87 static gdbarch_push_return_address_ftype ia64_push_return_address;
  88 static gdbarch_pop_frame_ftype ia64_pop_frame;
  89 static gdbarch_saved_pc_after_call_ftype ia64_saved_pc_after_call;
  90 static void ia64_pop_frame_regular (struct frame_info *frame);
  91 static struct type *is_float_or_hfa_type (struct type *t);
  92
  93 static int ia64_num_regs = 590;
  94
  95 static int pc_regnum = IA64_IP_REGNUM;
  96 static int sp_regnum = IA64_GR12_REGNUM;
  97 static int fp_regnum = IA64_VFP_REGNUM;
  98 static int lr_regnum = IA64_VRAP_REGNUM;
  99
 100 static LONGEST ia64_call_dummy_words[] = {0};
 101
 102 /* Array of register names; There should be ia64_num_regs strings in
 103    the initializer.  */
 104
 105 static char *ia64_register_names[] =
 106 { "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 107   "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 108   "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
 109   "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
 110   "r32",  "r33",  "r34",  "r35",  "r36",  "r37",  "r38",  "r39",
 111   "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
 112   "r48",  "r49",  "r50",  "r51",  "r52",  "r53",  "r54",  "r55",
 113   "r56",  "r57",  "r58",  "r59",  "r60",  "r61",  "r62",  "r63",
 114   "r64",  "r65",  "r66",  "r67",  "r68",  "r69",  "r70",  "r71",
 115   "r72",  "r73",  "r74",  "r75",  "r76",  "r77",  "r78",  "r79",
 116   "r80",  "r81",  "r82",  "r83",  "r84",  "r85",  "r86",  "r87",
 117   "r88",  "r89",  "r90",  "r91",  "r92",  "r93",  "r94",  "r95",
 118   "r96",  "r97",  "r98",  "r99",  "r100", "r101", "r102", "r103",
 119   "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
 120   "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
 121   "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
 122
 123   "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 124   "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 125   "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 126   "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 127   "f32",  "f33",  "f34",  "f35",  "f36",  "f37",  "f38",  "f39",
 128   "f40",  "f41",  "f42",  "f43",  "f44",  "f45",  "f46",  "f47",
 129   "f48",  "f49",  "f50",  "f51",  "f52",  "f53",  "f54",  "f55",
 130   "f56",  "f57",  "f58",  "f59",  "f60",  "f61",  "f62",  "f63",
 131   "f64",  "f65",  "f66",  "f67",  "f68",  "f69",  "f70",  "f71",
 132   "f72",  "f73",  "f74",  "f75",  "f76",  "f77",  "f78",  "f79",
 133   "f80",  "f81",  "f82",  "f83",  "f84",  "f85",  "f86",  "f87",
 134   "f88",  "f89",  "f90",  "f91",  "f92",  "f93",  "f94",  "f95",
 135   "f96",  "f97",  "f98",  "f99",  "f100", "f101", "f102", "f103",
 136   "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
 137   "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
 138   "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
 139
 140   "p0",   "p1",   "p2",   "p3",   "p4",   "p5",   "p6",   "p7",
 141   "p8",   "p9",   "p10",  "p11",  "p12",  "p13",  "p14",  "p15",
 142   "p16",  "p17",  "p18",  "p19",  "p20",  "p21",  "p22",  "p23",
 143   "p24",  "p25",  "p26",  "p27",  "p28",  "p29",  "p30",  "p31",
 144   "p32",  "p33",  "p34",  "p35",  "p36",  "p37",  "p38",  "p39",
 145   "p40",  "p41",  "p42",  "p43",  "p44",  "p45",  "p46",  "p47",
 146   "p48",  "p49",  "p50",  "p51",  "p52",  "p53",  "p54",  "p55",
 147   "p56",  "p57",  "p58",  "p59",  "p60",  "p61",  "p62",  "p63",
 148
 149   "b0",   "b1",   "b2",   "b3",   "b4",   "b5",   "b6",   "b7",
 150
 151   "vfp", "vrap",
 152
 153   "pr", "ip", "psr", "cfm",
 154
 155   "kr0",   "kr1",   "kr2",   "kr3",   "kr4",   "kr5",   "kr6",   "kr7",
 156   "", "", "", "", "", "", "", "",
 157   "rsc", "bsp", "bspstore", "rnat",
 158   "", "fcr", "", "",
 159   "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr",  "",
 160   "ccv", "", "", "", "unat", "", "", "",
 161   "fpsr", "", "", "", "itc",
 162   "", "", "", "", "", "", "", "", "", "",
 163   "", "", "", "", "", "", "", "", "",
 164   "pfs", "lc", "ec",
 165   "", "", "", "", "", "", "", "", "", "",
 166   "", "", "", "", "", "", "", "", "", "",
 167   "", "", "", "", "", "", "", "", "", "",
 168   "", "", "", "", "", "", "", "", "", "",
 169   "", "", "", "", "", "", "", "", "", "",
 170   "", "", "", "", "", "", "", "", "", "",
 171   "",
 172   "nat0",  "nat1",  "nat2",  "nat3",  "nat4",  "nat5",  "nat6",  "nat7",
 173   "nat8",  "nat9",  "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
 174   "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
 175   "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
 176   "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
 177   "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
 178   "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
 179   "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
 180   "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
 181   "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
 182   "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
 183   "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
 184   "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
 185   "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
 186   "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
 187   "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
 188 };
 189
 190 struct frame_extra_info
 191 {
 192   CORE_ADDR bsp;        /* points at r32 for the current frame */
 193   CORE_ADDR cfm;        /* cfm value for current frame */
 194   int       sof;        /* Size of frame  (decoded from cfm value) */
 195   int       sol;        /* Size of locals (decoded from cfm value) */
 196   CORE_ADDR after_prologue;
 197                         /* Address of first instruction after the last
 198                            prologue instruction;  Note that there may
 199                            be instructions from the function's body
 200                            intermingled with the prologue. */
 201   int       mem_stack_frame_size;
 202                         /* Size of the memory stack frame (may be zero),
 203                            or -1 if it has not been determined yet. */
 204   int       fp_reg;     /* Register number (if any) used a frame pointer
 205                            for this frame.  0 if no register is being used
 206                            as the frame pointer. */
 207 };
 208
 209 static char *
 210 ia64_register_name (int reg)
 211 {
 212   return ia64_register_names[reg];
 213 }
 214
 215 int
 216 ia64_register_raw_size (int reg)
 217 {
 218   return (IA64_FR0_REGNUM <= reg && reg <= IA64_FR127_REGNUM) ? 16 : 8;
 219 }
 220
 221 int
 222 ia64_register_virtual_size (int reg)
 223 {
 224   return (IA64_FR0_REGNUM <= reg && reg <= IA64_FR127_REGNUM) ? 16 : 8;
 225 }
 226
 227 /* Return true iff register N's virtual format is different from
 228    its raw format. */
 229 int
 230 ia64_register_convertible (int nr)
 231 {
 232   return (IA64_FR0_REGNUM <= nr && nr <= IA64_FR127_REGNUM);
 233 }
 234
 235 const struct floatformat floatformat_ia64_ext =
 236 {
 237   floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 238   floatformat_intbit_yes
 239 };
 240
 241 void
 242 ia64_register_convert_to_virtual (int regnum, struct type *type,
 243                                   char *from, char *to)
 244 {
 245   if (regnum >= IA64_FR0_REGNUM && regnum <= IA64_FR127_REGNUM)
 246     {
 247       DOUBLEST val;
 248       floatformat_to_doublest (&floatformat_ia64_ext, from, &val);
 249       store_floating(to, TYPE_LENGTH(type), val);
 250     }
 251   else
 252     error("ia64_register_convert_to_virtual called with non floating point register number");
 253 }
 254
 255 void
 256 ia64_register_convert_to_raw (struct type *type, int regnum,
 257                               char *from, char *to)
 258 {
 259   if (regnum >= IA64_FR0_REGNUM && regnum <= IA64_FR127_REGNUM)
 260     {
 261       DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
 262       floatformat_from_doublest (&floatformat_ia64_ext, &val, to);
 263     }
 264   else
 265     error("ia64_register_convert_to_raw called with non floating point register number");
 266 }
 267
 268 struct type *
 269 ia64_register_virtual_type (int reg)
 270 {
 271   if (reg >= IA64_FR0_REGNUM && reg <= IA64_FR127_REGNUM)
 272     return builtin_type_long_double;
 273   else
 274     return builtin_type_long;
 275 }
 276
 277 int
 278 ia64_register_byte (int reg)
 279 {
 280   return (8 * reg) +
 281    (reg <= IA64_FR0_REGNUM ? 0 : 8 * ((reg > IA64_FR127_REGNUM) ? 128 : reg - IA64_FR0_REGNUM));
 282 }
 283
 284 /* Extract ``len'' bits from an instruction bundle starting at
 285    bit ``from''.  */
 286
 287 long long
 288 extract_bit_field (char *bundle, int from, int len)
 289 {
 290   long long result = 0LL;
 291   int to = from + len;
 292   int from_byte = from / 8;
 293   int to_byte = to / 8;
 294   unsigned char *b = (unsigned char *) bundle;
 295   unsigned char c;
 296   int lshift;
 297   int i;
 298
 299   c = b[from_byte];
 300   if (from_byte == to_byte)
 301     c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
 302   result = c >> (from % 8);
 303   lshift = 8 - (from % 8);
 304
 305   for (i = from_byte+1; i < to_byte; i++)
 306     {
 307       result |= ((long long) b[i]) << lshift;
 308       lshift += 8;
 309     }
 310
 311   if (from_byte < to_byte && (to % 8 != 0))
 312     {
 313       c = b[to_byte];
 314       c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
 315       result |= ((long long) c) << lshift;
 316     }
 317
 318   return result;
 319 }
 320
 321 /* Replace the specified bits in an instruction bundle */
 322
 323 void
 324 replace_bit_field (char *bundle, long long val, int from, int len)
 325 {
 326   int to = from + len;
 327   int from_byte = from / 8;
 328   int to_byte = to / 8;
 329   unsigned char *b = (unsigned char *) bundle;
 330   unsigned char c;
 331
 332   if (from_byte == to_byte)
 333     {
 334       unsigned char left, right;
 335       c = b[from_byte];
 336       left = (c >> (to % 8)) << (to % 8);
 337       right = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
 338       c = (unsigned char) (val & 0xff);
 339       c = (unsigned char) (c << (from % 8 + 8 - to % 8)) >> (8 - to % 8);
 340       c |= right | left;
 341       b[from_byte] = c;
 342     }
 343   else
 344     {
 345       int i;
 346       c = b[from_byte];
 347       c = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
 348       c = c | (val << (from % 8));
 349       b[from_byte] = c;
 350       val >>= 8 - from % 8;
 351
 352       for (i = from_byte+1; i < to_byte; i++)
 353         {
 354           c = val & 0xff;
 355           val >>= 8;
 356           b[i] = c;
 357         }
 358
 359       if (to % 8 != 0)
 360         {
 361           unsigned char cv = (unsigned char) val;
 362           c = b[to_byte];
 363           c = c >> (to % 8) << (to % 8);
 364           c |= ((unsigned char) (cv << (8 - to % 8))) >> (8 - to % 8);
 365           b[to_byte] = c;
 366         }
 367     }
 368 }
 369
 370 /* Return the contents of slot N (for N = 0, 1, or 2) in
 371    and instruction bundle */
 372
 373 long long
 374 slotN_contents (unsigned char *bundle, int slotnum)
 375 {
 376   return extract_bit_field (bundle, 5+41*slotnum, 41);
 377 }
 378
 379 /* Store an instruction in an instruction bundle */
 380
 381 void
 382 replace_slotN_contents (unsigned char *bundle, long long instr, int slotnum)
 383 {
 384   replace_bit_field (bundle, instr, 5+41*slotnum, 41);
 385 }
 386
 387 static enum instruction_type template_encoding_table[32][3] =
 388 {
 389   { M, I, I },                          /* 00 */
 390   { M, I, I },                          /* 01 */
 391   { M, I, I },                          /* 02 */
 392   { M, I, I },                          /* 03 */
 393   { M, L, X },                          /* 04 */
 394   { M, L, X },                          /* 05 */
 395   { undefined, undefined, undefined },  /* 06 */
 396   { undefined, undefined, undefined },  /* 07 */
 397   { M, M, I },                          /* 08 */
 398   { M, M, I },                          /* 09 */
 399   { M, M, I },                          /* 0A */
 400   { M, M, I },                          /* 0B */
 401   { M, F, I },                          /* 0C */
 402   { M, F, I },                          /* 0D */
 403   { M, M, F },                          /* 0E */
 404   { M, M, F },                          /* 0F */
 405   { M, I, B },                          /* 10 */
 406   { M, I, B },                          /* 11 */
 407   { M, B, B },                          /* 12 */
 408   { M, B, B },                          /* 13 */
 409   { undefined, undefined, undefined },  /* 14 */
 410   { undefined, undefined, undefined },  /* 15 */
 411   { B, B, B },                          /* 16 */
 412   { B, B, B },                          /* 17 */
 413   { M, M, B },                          /* 18 */
 414   { M, M, B },                          /* 19 */
 415   { undefined, undefined, undefined },  /* 1A */
 416   { undefined, undefined, undefined },  /* 1B */
 417   { M, F, B },                          /* 1C */
 418   { M, F, B },                          /* 1D */
 419   { undefined, undefined, undefined },  /* 1E */
 420   { undefined, undefined, undefined },  /* 1F */
 421 };
 422
 423 /* Fetch and (partially) decode an instruction at ADDR and return the
 424    address of the next instruction to fetch.  */
 425
 426 static CORE_ADDR
 427 fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr)
 428 {
 429   char bundle[BUNDLE_LEN];
 430   int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
 431   long long template;
 432   int val;
 433
 434   if (slotnum > 2)
 435     error("Can't fetch instructions for slot numbers greater than 2.");
 436
 437   addr &= ~0x0f;
 438
 439   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 440
 441   if (val != 0)
 442     return 0;
 443
 444   *instr = slotN_contents (bundle, slotnum);
 445   template = extract_bit_field (bundle, 0, 5);
 446   *it = template_encoding_table[(int)template][slotnum];
 447
 448   if (slotnum == 2 || (slotnum == 1 && *it == L))
 449     addr += 16;
 450   else
 451     addr += (slotnum + 1) * SLOT_MULTIPLIER;
 452
 453   return addr;
 454 }
 455
 456 /* There are 5 different break instructions (break.i, break.b,
 457    break.m, break.f, and break.x), but they all have the same
 458    encoding.  (The five bit template in the low five bits of the
 459    instruction bundle distinguishes one from another.)
 460
 461    The runtime architecture manual specifies that break instructions
 462    used for debugging purposes must have the upper two bits of the 21
 463    bit immediate set to a 0 and a 1 respectively.  A breakpoint
 464    instruction encodes the most significant bit of its 21 bit
 465    immediate at bit 36 of the 41 bit instruction.  The penultimate msb
 466    is at bit 25 which leads to the pattern below.
 467
 468    Originally, I had this set up to do, e.g, a "break.i 0x80000"  But
 469    it turns out that 0x80000 was used as the syscall break in the early
 470    simulators.  So I changed the pattern slightly to do "break.i 0x080001"
 471    instead.  But that didn't work either (I later found out that this
 472    pattern was used by the simulator that I was using.)  So I ended up
 473    using the pattern seen below. */
 474
 475 #if 0
 476 #define BREAKPOINT 0x00002000040LL
 477 #endif
 478 #define BREAKPOINT 0x00003333300LL
 479
 480 static int
 481 ia64_memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
 482 {
 483   char bundle[BUNDLE_LEN];
 484   int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
 485   long long instr;
 486   int val;
 487
 488   if (slotnum > 2)
 489     error("Can't insert breakpoint for slot numbers greater than 2.");
 490
 491   addr &= ~0x0f;
 492
 493   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 494   instr = slotN_contents (bundle, slotnum);
 495   memcpy(contents_cache, &instr, sizeof(instr));
 496   replace_slotN_contents (bundle, BREAKPOINT, slotnum);
 497   if (val == 0)
 498     target_write_memory (addr, bundle, BUNDLE_LEN);
 499
 500   return val;
 501 }
 502
 503 static int
 504 ia64_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 505 {
 506   char bundle[BUNDLE_LEN];
 507   int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER;
 508   long long instr;
 509   int val;
 510
 511   addr &= ~0x0f;
 512
 513   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 514   memcpy (&instr, contents_cache, sizeof instr);
 515   replace_slotN_contents (bundle, instr, slotnum);
 516   if (val == 0)
 517     target_write_memory (addr, bundle, BUNDLE_LEN);
 518
 519   return val;
 520 }
 521
 522 /* We don't really want to use this, but remote.c needs to call it in order
 523    to figure out if Z-packets are supported or not.  Oh, well. */
 524 unsigned char *
 525 ia64_breakpoint_from_pc (pcptr, lenptr)
 526      CORE_ADDR *pcptr;
 527      int *lenptr;
 528 {
 529   static unsigned char breakpoint[] =
 530     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 531   *lenptr = sizeof (breakpoint);
 532 #if 0
 533   *pcptr &= ~0x0f;
 534 #endif
 535   return breakpoint;
 536 }
 537
 538 CORE_ADDR
 539 ia64_read_pc (int pid)
 540 {
 541   CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, pid);
 542   CORE_ADDR pc_value   = read_register_pid (IA64_IP_REGNUM, pid);
 543   int slot_num = (psr_value >> 41) & 3;
 544
 545   return pc_value | (slot_num * SLOT_MULTIPLIER);
 546 }
 547
 548 void
 549 ia64_write_pc (CORE_ADDR new_pc, int pid)
 550 {
 551   int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
 552   CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, pid);
 553   psr_value &= ~(3LL << 41);
 554   psr_value |= (CORE_ADDR)(slot_num & 0x3) << 41;
 555
 556   new_pc &= ~0xfLL;
 557
 558   write_register_pid (IA64_PSR_REGNUM, psr_value, pid);
 559   write_register_pid (IA64_IP_REGNUM, new_pc, pid);
 560 }
 561
 562 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
 563
 564 /* Returns the address of the slot that's NSLOTS slots away from
 565    the address ADDR. NSLOTS may be positive or negative. */
 566 static CORE_ADDR
 567 rse_address_add(CORE_ADDR addr, int nslots)
 568 {
 569   CORE_ADDR new_addr;
 570   int mandatory_nat_slots = nslots / 63;
 571   int direction = nslots < 0 ? -1 : 1;
 572
 573   new_addr = addr + 8 * (nslots + mandatory_nat_slots);
 574
 575   if ((new_addr >> 9)  != ((addr + 8 * 64 * mandatory_nat_slots) >> 9))
 576     new_addr += 8 * direction;
 577
 578   if (IS_NaT_COLLECTION_ADDR(new_addr))
 579     new_addr += 8 * direction;
 580
 581   return new_addr;
 582 }
 583
 584 /* The IA-64 frame chain is a bit odd.  We won't always have a frame
 585    pointer, so we use the SP value as the FP for the purpose of
 586    creating a frame.  There is sometimes a register (not fixed) which
 587    is used as a frame pointer.  When this register exists, it is not
 588    especially hard to determine which one is being used.  It isn't
 589    even really hard to compute the frame chain, but it can be
 590    computationally expensive.  So, instead of making life difficult
 591    (and slow), we pick a more convenient representation of the frame
 592    chain, knowing that we'll have to make some small adjustments
 593    in other places.  (E.g, note that read_fp() and write_fp() are
 594    actually read_sp() and write_sp() below in ia64_gdbarch_init()
 595    below.)
 596
 597    Okay, so what is the frame chain exactly?  It'll be the SP value
 598    at the time that the function in question was entered.
 599
 600    Note that this *should* actually the frame pointer for the current
 601    function!  But as I note above, if we were to attempt to find the
 602    address of the beginning of the previous frame, we'd waste a lot
 603    of cycles for no good reason.  So instead, we simply choose to
 604    represent the frame chain as the end of the previous frame instead
 605    of the beginning.  */
 606
 607 CORE_ADDR
 608 ia64_frame_chain (struct frame_info *frame)
 609 {
 610   FRAME_INIT_SAVED_REGS (frame);
 611
 612   if (frame->saved_regs[IA64_VFP_REGNUM])
 613     return read_memory_integer (frame->saved_regs[IA64_VFP_REGNUM], 8);
 614   else
 615     return frame->frame + frame->extra_info->mem_stack_frame_size;
 616 }
 617
 618 CORE_ADDR
 619 ia64_frame_saved_pc (struct frame_info *frame)
 620 {
 621   FRAME_INIT_SAVED_REGS (frame);
 622
 623   if (frame->saved_regs[IA64_VRAP_REGNUM])
 624     return read_memory_integer (frame->saved_regs[IA64_VRAP_REGNUM], 8);
 625   else  /* either frameless, or not far enough along in the prologue... */
 626     return ia64_saved_pc_after_call (frame);
 627 }
 628
 629 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
 630   || (8 <= (_regnum_) && (_regnum_) <= 11) \
 631   || (14 <= (_regnum_) && (_regnum_) <= 31))
 632 #define imm9(_instr_) \
 633   ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
 634    | (((_instr_) & 0x00008000000LL) >> 20) \
 635    | (((_instr_) & 0x00000001fc0LL) >> 6))
 636
 637 static CORE_ADDR
 638 examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
 639 {
 640   CORE_ADDR next_pc;
 641   CORE_ADDR last_prologue_pc = pc;
 642   instruction_type it;
 643   long long instr;
 644   int do_fsr_stuff = 0;
 645
 646   int cfm_reg  = 0;
 647   int ret_reg  = 0;
 648   int fp_reg   = 0;
 649   int unat_save_reg = 0;
 650   int pr_save_reg = 0;
 651   int mem_stack_frame_size = 0;
 652   int spill_reg   = 0;
 653   CORE_ADDR spill_addr = 0;
 654
 655   if (frame && !frame->saved_regs)
 656     {
 657       frame_saved_regs_zalloc (frame);
 658       do_fsr_stuff = 1;
 659     }
 660
 661   if (frame
 662       && !do_fsr_stuff
 663       && frame->extra_info->after_prologue != 0
 664       && frame->extra_info->after_prologue <= lim_pc)
 665     return frame->extra_info->after_prologue;
 666
 667   /* Must start with an alloc instruction */
 668   next_pc = fetch_instruction (pc, &it, &instr);
 669   if (pc < lim_pc && next_pc
 670       && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL))
 671     {
 672       /* alloc */
 673       int sor = (int) ((instr & 0x00078000000LL) >> 27);
 674       int sol = (int) ((instr & 0x00007f00000LL) >> 20);
 675       int sof = (int) ((instr & 0x000000fe000LL) >> 13);
 676       /* Okay, so sor, sol, and sof aren't used right now; but perhaps
 677          we could compare against the size given to us via the cfm as
 678          either a sanity check or possibly to see if the frame has been
 679          changed by a later alloc instruction... */
 680       int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 681       cfm_reg = rN;
 682       last_prologue_pc = next_pc;
 683       pc = next_pc;
 684     }
 685   else
 686     pc = lim_pc;        /* We're done early */
 687
 688   /* Loop, looking for prologue instructions, keeping track of
 689      where preserved registers were spilled. */
 690   while (pc < lim_pc)
 691     {
 692       next_pc = fetch_instruction (pc, &it, &instr);
 693       if (next_pc == 0)
 694         break;
 695
 696       if (it == I && ((instr & 0x1eff8000000LL) == 0x00188000000LL))
 697         {
 698           /* Move from BR */
 699           int b2 = (int) ((instr & 0x0000000e000LL) >> 13);
 700           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 701           int qp = (int) (instr & 0x0000000003f);
 702
 703           if (qp == 0 && b2 == 0 && rN >= 32 && ret_reg == 0)
 704             {
 705               ret_reg = rN;
 706               last_prologue_pc = next_pc;
 707             }
 708         }
 709       else if ((it == I || it == M)
 710           && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
 711         {
 712           /* adds rN = imm14, rM   (or mov rN, rM  when imm14 is 0) */
 713           int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
 714                            | ((instr & 0x001f8000000LL) >> 20)
 715                            | ((instr & 0x000000fe000LL) >> 13));
 716           int rM = (int) ((instr & 0x00007f00000LL) >> 20);
 717           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 718           int qp = (int) (instr & 0x0000000003fLL);
 719
 720           if (qp == 0 && rN >= 32 && imm == 0 && rM == 12 && fp_reg == 0)
 721             {
 722               /* mov rN, r12 */
 723               fp_reg = rN;
 724               last_prologue_pc = next_pc;
 725             }
 726           else if (qp == 0 && rN == 12 && rM == 12)
 727             {
 728               /* adds r12, -mem_stack_frame_size, r12 */
 729               mem_stack_frame_size -= imm;
 730               last_prologue_pc = next_pc;
 731             }
 732           else if (qp == 0 && rN == 2
 733                 && ((rM == fp_reg && fp_reg != 0) || rM == 12))
 734             {
 735               /* adds r2, spilloffset, rFramePointer
 736                    or
 737                  adds r2, spilloffset, r12
 738
 739                  Get ready for stf.spill or st8.spill instructions.
 740                  The address to start spilling at is loaded into r2.
 741                  FIXME:  Why r2?  That's what gcc currently uses; it
 742                  could well be different for other compilers.  */
 743
 744               /* Hmm... whether or not this will work will depend on
 745                  where the pc is.  If it's still early in the prologue
 746                  this'll be wrong.  FIXME */
 747               spill_addr  = (frame ? frame->frame : 0)
 748                           + (rM == 12 ? 0 : mem_stack_frame_size)
 749                           + imm;
 750               spill_reg   = rN;
 751               last_prologue_pc = next_pc;
 752             }
 753         }
 754       else if (it == M
 755             && (   ((instr & 0x1efc0000000LL) == 0x0eec0000000LL)
 756                 || ((instr & 0x1ffc8000000LL) == 0x0cec0000000LL) ))
 757         {
 758           /* stf.spill [rN] = fM, imm9
 759              or
 760              stf.spill [rN] = fM  */
 761
 762           int imm = imm9(instr);
 763           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
 764           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
 765           int qp = (int) (instr & 0x0000000003fLL);
 766           if (qp == 0 && rN == spill_reg && spill_addr != 0
 767               && ((2 <= fM && fM <= 5) || (16 <= fM && fM <= 31)))
 768             {
 769               if (do_fsr_stuff)
 770                 frame->saved_regs[IA64_FR0_REGNUM + fM] = spill_addr;
 771
 772               if ((instr & 0x1efc0000000) == 0x0eec0000000)
 773                 spill_addr += imm;
 774               else
 775                 spill_addr = 0;         /* last one; must be done */
 776               last_prologue_pc = next_pc;
 777             }
 778         }
 779       else if ((it == M && ((instr & 0x1eff8000000LL) == 0x02110000000LL))
 780             || (it == I && ((instr & 0x1eff8000000LL) == 0x00050000000LL)) )
 781         {
 782           /* mov.m rN = arM
 783                or
 784              mov.i rN = arM */
 785
 786           int arM = (int) ((instr & 0x00007f00000LL) >> 20);
 787           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
 788           int qp  = (int) (instr & 0x0000000003fLL);
 789           if (qp == 0 && isScratch (rN) && arM == 36 /* ar.unat */)
 790             {
 791               /* We have something like "mov.m r3 = ar.unat".  Remember the
 792                  r3 (or whatever) and watch for a store of this register... */
 793               unat_save_reg = rN;
 794               last_prologue_pc = next_pc;
 795             }
 796         }
 797       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00198000000LL))
 798         {
 799           /* mov rN = pr */
 800           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
 801           int qp  = (int) (instr & 0x0000000003fLL);
 802           if (qp == 0 && isScratch (rN))
 803             {
 804               pr_save_reg = rN;
 805               last_prologue_pc = next_pc;
 806             }
 807         }
 808       else if (it == M
 809             && (   ((instr & 0x1ffc8000000LL) == 0x08cc0000000LL)
 810                 || ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)))
 811         {
 812           /* st8 [rN] = rM
 813               or
 814              st8 [rN] = rM, imm9 */
 815           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
 816           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
 817           int qp = (int) (instr & 0x0000000003fLL);
 818           if (qp == 0 && rN == spill_reg && spill_addr != 0
 819               && (rM == unat_save_reg || rM == pr_save_reg))
 820             {
 821               /* We've found a spill of either the UNAT register or the PR
 822                  register.  (Well, not exactly; what we've actually found is
 823                  a spill of the register that UNAT or PR was moved to).
 824                  Record that fact and move on... */
 825               if (rM == unat_save_reg)
 826                 {
 827                   /* Track UNAT register */
 828                   if (do_fsr_stuff)
 829                     frame->saved_regs[IA64_UNAT_REGNUM] = spill_addr;
 830                   unat_save_reg = 0;
 831                 }
 832               else
 833                 {
 834                   /* Track PR register */
 835                   if (do_fsr_stuff)
 836                     frame->saved_regs[IA64_PR_REGNUM] = spill_addr;
 837                   pr_save_reg = 0;
 838                 }
 839               if ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)
 840                 /* st8 [rN] = rM, imm9 */
 841                 spill_addr += imm9(instr);
 842               else
 843                 spill_addr = 0;         /* must be done spilling */
 844               last_prologue_pc = next_pc;
 845             }
 846         }
 847       else if (it == M
 848             && (   ((instr & 0x1ffc8000000LL) == 0x08ec0000000LL)
 849                 || ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)))
 850         {
 851           /* st8.spill [rN] = rM
 852                or
 853              st8.spill [rN] = rM, imm9 */
 854           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
 855           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
 856           int qp = (int) (instr & 0x0000000003fLL);
 857           if (qp == 0 && rN == spill_reg && 4 <= rM && rM <= 7)
 858             {
 859               /* We've found a spill of one of the preserved general purpose
 860                  regs.  Record the spill address and advance the spill
 861                  register if appropriate. */
 862               if (do_fsr_stuff)
 863                 frame->saved_regs[IA64_GR0_REGNUM + rM] = spill_addr;
 864               if ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)
 865                 /* st8.spill [rN] = rM, imm9 */
 866                 spill_addr += imm9(instr);
 867               else
 868                 spill_addr = 0;         /* Done spilling */
 869               last_prologue_pc = next_pc;
 870             }
 871         }
 872       else if (it == B || ((instr & 0x3fLL) != 0LL))
 873         break;
 874
 875       pc = next_pc;
 876     }
 877
 878   if (do_fsr_stuff) {
 879     int i;
 880     CORE_ADDR addr;
 881
 882     for (i = 0, addr = frame->extra_info->bsp;
 883          i < frame->extra_info->sof;
 884          i++, addr += 8)
 885       {
 886         if (IS_NaT_COLLECTION_ADDR (addr))
 887           {
 888             addr += 8;
 889           }
 890         frame->saved_regs[IA64_GR32_REGNUM + i] = addr;
 891
 892         if (i+32 == cfm_reg)
 893           frame->saved_regs[IA64_CFM_REGNUM] = addr;
 894         if (i+32 == ret_reg)
 895           frame->saved_regs[IA64_VRAP_REGNUM] = addr;
 896         if (i+32 == fp_reg)
 897           frame->saved_regs[IA64_VFP_REGNUM] = addr;
 898       }
 899   }
 900
 901   if (frame && frame->extra_info) {
 902     frame->extra_info->after_prologue = last_prologue_pc;
 903     frame->extra_info->mem_stack_frame_size = mem_stack_frame_size;
 904     frame->extra_info->fp_reg = fp_reg;
 905   }
 906
 907   return last_prologue_pc;
 908 }
 909
 910 CORE_ADDR
 911 ia64_skip_prologue (CORE_ADDR pc)
 912 {
 913   return examine_prologue (pc, pc+1024, 0);
 914 }
 915
 916 void
 917 ia64_frame_init_saved_regs (struct frame_info *frame)
 918 {
 919   CORE_ADDR func_start;
 920
 921   if (frame->saved_regs)
 922     return;
 923
 924   func_start = get_pc_function_start (frame->pc);
 925   examine_prologue (func_start, frame->pc, frame);
 926 }
 927
 928 static CORE_ADDR
 929 ia64_find_saved_register (frame, regnum)
 930      struct frame_info *frame;
 931      int regnum;
 932 {
 933   register CORE_ADDR addr = 0;
 934
 935   if ((IA64_GR32_REGNUM <= regnum && regnum <= IA64_GR127_REGNUM)
 936       || regnum == IA64_VFP_REGNUM
 937       || regnum == IA64_VRAP_REGNUM)
 938     {
 939       FRAME_INIT_SAVED_REGS (frame);
 940       return frame->saved_regs[regnum];
 941     }
 942   else if (regnum == IA64_IP_REGNUM && frame->next)
 943     {
 944       FRAME_INIT_SAVED_REGS (frame->next);
 945       return frame->next->saved_regs[IA64_VRAP_REGNUM];
 946     }
 947   else
 948     {
 949       struct frame_info *frame1 = NULL;
 950       while (1)
 951         {
 952           QUIT;
 953           frame1 = get_prev_frame (frame1);
 954           if (frame1 == 0 || frame1 == frame)
 955             break;
 956           FRAME_INIT_SAVED_REGS (frame1);
 957           if (frame1->saved_regs[regnum])
 958             addr = frame1->saved_regs[regnum];
 959         }
 960     }
 961
 962   return addr;
 963 }
 964
 965 void
 966 ia64_get_saved_register (char *raw_buffer,
 967                          int *optimized,
 968                          CORE_ADDR *addrp,
 969                          struct frame_info *frame,
 970                          int regnum,
 971                          enum lval_type *lval)
 972 {
 973   CORE_ADDR addr;
 974
 975   if (!target_has_registers)
 976     error ("No registers.");
 977
 978   if (optimized != NULL)
 979     *optimized = 0;
 980   addr = ia64_find_saved_register (frame, regnum);
 981   if (addr != 0)
 982     {
 983       if (lval != NULL)
 984         *lval = lval_memory;
 985       if (regnum == SP_REGNUM)
 986         {
 987           if (raw_buffer != NULL)
 988             {
 989               /* Put it back in target format.  */
 990               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), (LONGEST) addr);
 991             }
 992           if (addrp != NULL)
 993             *addrp = 0;
 994           return;
 995         }
 996       if (raw_buffer != NULL)
 997         read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 998     }
 999   else if (IA64_GR32_REGNUM <= regnum && regnum <= IA64_GR127_REGNUM)
1000     {
1001       /* r32 - r127 must be fetchable via memory.  If they aren't,
1002          then the register is unavailable */
1003       addr = 0;
1004       if (lval != NULL)
1005         *lval = not_lval;
1006       memset (raw_buffer, 0, REGISTER_RAW_SIZE (regnum));
1007     }
1008   else if (regnum == IA64_IP_REGNUM)
1009     {
1010       CORE_ADDR pc;
1011       if (frame->next)
1012         {
1013           /* This case will normally be handled above, except when it's
1014              frameless or we haven't advanced far enough into the prologue
1015              of the top frame to save the register. */
1016           addr = REGISTER_BYTE (regnum);
1017           if (lval != NULL)
1018             *lval = lval_register;
1019           pc = ia64_saved_pc_after_call (frame);
1020         }
1021       else
1022         {
1023           addr = 0;
1024           if (lval != NULL)
1025             *lval = not_lval;
1026           pc = read_pc ();
1027         }
1028       store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_IP_REGNUM), pc);
1029     }
1030   else if (regnum == SP_REGNUM && frame->next)
1031     {
1032       /* Handle SP values for all frames but the topmost. */
1033       addr = 0;
1034       if (lval != NULL)
1035         *lval = not_lval;
1036       store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->frame);
1037     }
1038   else if (regnum == IA64_BSP_REGNUM)
1039     {
1040       addr = 0;
1041       if (lval != NULL)
1042         *lval = not_lval;
1043       store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1044                      frame->extra_info->bsp);
1045     }
1046   else if (regnum == IA64_VFP_REGNUM)
1047     {
1048       /* If the function in question uses an automatic register (r32-r127)
1049          for the frame pointer, it'll be found by ia64_find_saved_register()
1050          above.  If the function lacks one of these frame pointers, we can
1051          still provide a value since we know the size of the frame */
1052       CORE_ADDR vfp = frame->frame + frame->extra_info->mem_stack_frame_size;
1053       addr = 0;
1054       if (lval != NULL)
1055         *lval = not_lval;
1056       store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
1057     }
1058   else if (IA64_PR0_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1059     {
1060       char pr_raw_buffer[MAX_REGISTER_RAW_SIZE];
1061       int  pr_optim;
1062       enum lval_type pr_lval;
1063       CORE_ADDR pr_addr;
1064       int prN_val;
1065       ia64_get_saved_register (pr_raw_buffer, &pr_optim, &pr_addr,
1066                                frame, IA64_PR_REGNUM, &pr_lval);
1067       prN_val = extract_bit_field ((unsigned char *) pr_raw_buffer,
1068                                    regnum - IA64_PR0_REGNUM, 1);
1069       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), prN_val);
1070       addr = 0;
1071       if (lval != NULL)
1072         *lval = not_lval;
1073     }
1074   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
1075     {
1076       char unat_raw_buffer[MAX_REGISTER_RAW_SIZE];
1077       int  unat_optim;
1078       enum lval_type unat_lval;
1079       CORE_ADDR unat_addr;
1080       int unatN_val;
1081       ia64_get_saved_register (unat_raw_buffer, &unat_optim, &unat_addr,
1082                                frame, IA64_UNAT_REGNUM, &unat_lval);
1083       unatN_val = extract_bit_field ((unsigned char *) unat_raw_buffer,
1084                                    regnum - IA64_NAT0_REGNUM, 1);
1085       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
1086                               unatN_val);
1087       addr = 0;
1088       if (lval != NULL)
1089         *lval = not_lval;
1090     }
1091   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
1092     {
1093       int natval = 0;
1094       /* Find address of general register corresponding to nat bit we're
1095          interested in. */
1096       CORE_ADDR gr_addr =
1097         ia64_find_saved_register (frame,
1098                                   regnum - IA64_NAT0_REGNUM + IA64_GR0_REGNUM);
1099       if (gr_addr)
1100         {
1101           /* Compute address of nat collection bits */
1102           CORE_ADDR nat_addr = gr_addr | 0x1f8;
1103           CORE_ADDR bsp = read_register (IA64_BSP_REGNUM);
1104           CORE_ADDR nat_collection;
1105           int nat_bit;
1106           /* If our nat collection address is bigger than bsp, we have to get
1107              the nat collection from rnat.  Otherwise, we fetch the nat
1108              collection from the computed address. */
1109           if (nat_addr >= bsp)
1110             nat_collection = read_register (IA64_RNAT_REGNUM);
1111           else
1112             nat_collection = read_memory_integer (nat_addr, 8);
1113           nat_bit = (gr_addr >> 3) & 0x3f;
1114           natval = (nat_collection >> nat_bit) & 1;
1115         }
1116       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), natval);
1117       addr = 0;
1118       if (lval != NULL)
1119         *lval = not_lval;
1120     }
1121   else
1122     {
1123       if (lval != NULL)
1124         *lval = lval_register;
1125       addr = REGISTER_BYTE (regnum);
1126       if (raw_buffer != NULL)
1127         read_register_gen (regnum, raw_buffer);
1128     }
1129   if (addrp != NULL)
1130     *addrp = addr;
1131 }
1132
1133 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1134    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1135    and TYPE is the type (which is known to be struct, union or array).  */
1136 int
1137 ia64_use_struct_convention (int gcc_p, struct type *type)
1138 {
1139   struct type *float_elt_type;
1140
1141   /* HFAs are structures (or arrays) consisting entirely of floating
1142      point values of the same length.  Up to 8 of these are returned
1143      in registers.  Don't use the struct convention when this is the
1144      case. */
1145   float_elt_type = is_float_or_hfa_type (type);
1146   if (float_elt_type != NULL
1147       && TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type) <= 8)
1148     return 0;
1149
1150   /* Other structs of length 32 or less are returned in r8-r11.
1151      Don't use the struct convention for those either. */
1152   return TYPE_LENGTH (type) > 32;
1153 }
1154
1155 void
1156 ia64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1157 {
1158   struct type *float_elt_type;
1159
1160   float_elt_type = is_float_or_hfa_type (type);
1161   if (float_elt_type != NULL)
1162     {
1163       int offset = 0;
1164       int regnum = IA64_FR8_REGNUM;
1165       int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
1166
1167       while (n-- > 0)
1168         {
1169           ia64_register_convert_to_virtual (regnum, float_elt_type,
1170             &regbuf[REGISTER_BYTE (regnum)], valbuf + offset);
1171           offset += TYPE_LENGTH (float_elt_type);
1172           regnum++;
1173         }
1174     }
1175   else
1176     memcpy (valbuf, &regbuf[REGISTER_BYTE (IA64_GR8_REGNUM)],
1177             TYPE_LENGTH (type));
1178 }
1179
1180 /* FIXME: Turn this into a stack of some sort.  Unfortunately, something
1181    like this is necessary though since the IA-64 calling conventions specify
1182    that r8 is not preserved. */
1183 static CORE_ADDR struct_return_address;
1184
1185 CORE_ADDR
1186 ia64_extract_struct_value_address (char *regbuf)
1187 {
1188   /* FIXME: See above. */
1189   return struct_return_address;
1190 }
1191
1192 void
1193 ia64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1194 {
1195   /* FIXME: See above. */
1196   /* Note that most of the work was done in ia64_push_arguments() */
1197   struct_return_address = addr;
1198 }
1199
1200 int
1201 ia64_frameless_function_invocation (struct frame_info *frame)
1202 {
1203   /* FIXME: Implement */
1204   return 0;
1205 }
1206
1207 CORE_ADDR
1208 ia64_saved_pc_after_call (struct frame_info *frame)
1209 {
1210   return read_register (IA64_BR0_REGNUM);
1211 }
1212
1213 CORE_ADDR
1214 ia64_frame_args_address (struct frame_info *frame)
1215 {
1216   /* frame->frame points at the SP for this frame; But we want the start
1217      of the frame, not the end.  Calling frame chain will get his for us. */
1218   return ia64_frame_chain (frame);
1219 }
1220
1221 CORE_ADDR
1222 ia64_frame_locals_address (struct frame_info *frame)
1223 {
1224   /* frame->frame points at the SP for this frame; But we want the start
1225      of the frame, not the end.  Calling frame chain will get his for us. */
1226   return ia64_frame_chain (frame);
1227 }
1228
1229 void
1230 ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
1231 {
1232   CORE_ADDR bsp, cfm;
1233
1234   frame->extra_info = (struct frame_extra_info *)
1235     frame_obstack_alloc (sizeof (struct frame_extra_info));
1236
1237   if (frame->next == 0)
1238     {
1239       bsp = read_register (IA64_BSP_REGNUM);
1240       cfm = read_register (IA64_CFM_REGNUM);
1241
1242     }
1243   else
1244     {
1245       struct frame_info *frn = frame->next;
1246
1247       FRAME_INIT_SAVED_REGS (frn);
1248
1249       if (frn->saved_regs[IA64_CFM_REGNUM] != 0)
1250         cfm = read_memory_integer (frn->saved_regs[IA64_CFM_REGNUM], 8);
1251       else
1252         cfm = read_register (IA64_PFS_REGNUM);
1253
1254       bsp = frn->extra_info->bsp;
1255     }
1256   frame->extra_info->cfm = cfm;
1257   frame->extra_info->sof = cfm & 0x7f;
1258   frame->extra_info->sol = (cfm >> 7) & 0x7f;
1259   if (frame->next == 0)
1260     frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sof);
1261   else
1262     frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sol);
1263
1264   frame->extra_info->after_prologue = 0;
1265   frame->extra_info->mem_stack_frame_size = -1;         /* Not yet determined */
1266   frame->extra_info->fp_reg = 0;
1267 }
1268
1269 static int
1270 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
1271 {
1272   switch (TYPE_CODE (t))
1273     {
1274     case TYPE_CODE_FLT:
1275       if (*etp)
1276         return TYPE_LENGTH (*etp) == TYPE_LENGTH (t);
1277       else
1278         {
1279           *etp = t;
1280           return 1;
1281         }
1282       break;
1283     case TYPE_CODE_ARRAY:
1284       return is_float_or_hfa_type_recurse (TYPE_TARGET_TYPE (t), etp);
1285       break;
1286     case TYPE_CODE_STRUCT:
1287       {
1288         int i;
1289
1290         for (i = 0; i < TYPE_NFIELDS (t); i++)
1291           if (!is_float_or_hfa_type_recurse (TYPE_FIELD_TYPE (t, i), etp))
1292             return 0;
1293         return 1;
1294       }
1295       break;
1296     default:
1297       return 0;
1298       break;
1299     }
1300 }
1301
1302 /* Determine if the given type is one of the floating point types or
1303    and HFA (which is a struct, array, or combination thereof whose
1304    bottom-most elements are all of the same floating point type.) */
1305
1306 static struct type *
1307 is_float_or_hfa_type (struct type *t)
1308 {
1309   struct type *et = 0;
1310
1311   return is_float_or_hfa_type_recurse (t, &et) ? et : 0;
1312 }
1313
1314
1315 /* Attempt to find (and return) the global pointer for the given
1316    function.
1317
1318    This is a rather nasty bit of code searchs for the .dynamic section
1319    in the objfile corresponding to the pc of the function we're trying
1320    to call.  Once it finds the addresses at which the .dynamic section
1321    lives in the child process, it scans the Elf64_Dyn entries for a
1322    DT_PLTGOT tag.  If it finds one of these, the corresponding
1323    d_un.d_ptr value is the global pointer.  */
1324
1325 static CORE_ADDR
1326 find_global_pointer (CORE_ADDR faddr)
1327 {
1328   struct obj_section *faddr_sect;
1329
1330   faddr_sect = find_pc_section (faddr);
1331   if (faddr_sect != NULL)
1332     {
1333       struct obj_section *osect;
1334
1335       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1336         {
1337           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
1338             break;
1339         }
1340
1341       if (osect < faddr_sect->objfile->sections_end)
1342         {
1343           CORE_ADDR addr;
1344
1345           addr = osect->addr;
1346           while (addr < osect->endaddr)
1347             {
1348               int status;
1349               LONGEST tag;
1350               char buf[8];
1351
1352               status = target_read_memory (addr, buf, sizeof (buf));
1353               if (status != 0)
1354                 break;
1355               tag = extract_signed_integer (buf, sizeof (buf));
1356
1357               if (tag == DT_PLTGOT)
1358                 {
1359                   CORE_ADDR global_pointer;
1360
1361                   status = target_read_memory (addr + 8, buf, sizeof (buf));
1362                   if (status != 0)
1363                     break;
1364                   global_pointer = extract_address (buf, sizeof (buf));
1365
1366                   /* The payoff... */
1367                   return global_pointer;
1368                 }
1369
1370               if (tag == DT_NULL)
1371                 break;
1372
1373               addr += 16;
1374             }
1375         }
1376     }
1377   return 0;
1378 }
1379
1380 /* Given a function's address, attempt to find (and return) the
1381    corresponding (canonical) function descriptor.  Return 0 if
1382    not found. */
1383 static CORE_ADDR
1384 find_extant_func_descr (CORE_ADDR faddr)
1385 {
1386   struct obj_section *faddr_sect;
1387
1388   /* Return early if faddr is already a function descriptor */
1389   faddr_sect = find_pc_section (faddr);
1390   if (faddr_sect && strcmp (faddr_sect->the_bfd_section->name, ".opd") == 0)
1391     return faddr;
1392
1393   if (faddr_sect != NULL)
1394     {
1395       struct obj_section *osect;
1396       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1397         {
1398           if (strcmp (osect->the_bfd_section->name, ".opd") == 0)
1399             break;
1400         }
1401
1402       if (osect < faddr_sect->objfile->sections_end)
1403         {
1404           CORE_ADDR addr;
1405
1406           addr = osect->addr;
1407           while (addr < osect->endaddr)
1408             {
1409               int status;
1410               LONGEST faddr2;
1411               char buf[8];
1412
1413               status = target_read_memory (addr, buf, sizeof (buf));
1414               if (status != 0)
1415                 break;
1416               faddr2 = extract_signed_integer (buf, sizeof (buf));
1417
1418               if (faddr == faddr2)
1419                 return addr;
1420
1421               addr += 16;
1422             }
1423         }
1424     }
1425   return 0;
1426 }
1427
1428 /* Attempt to find a function descriptor corresponding to the
1429    given address.  If none is found, construct one on the
1430    stack using the address at fdaptr */
1431
1432 static CORE_ADDR
1433 find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
1434 {
1435   CORE_ADDR fdesc;
1436
1437   fdesc = find_extant_func_descr (faddr);
1438
1439   if (fdesc == 0)
1440     {
1441       CORE_ADDR global_pointer;
1442       char buf[16];
1443
1444       fdesc = *fdaptr;
1445       *fdaptr += 16;
1446
1447       global_pointer = find_global_pointer (faddr);
1448
1449       if (global_pointer == 0)
1450         global_pointer = read_register (IA64_GR1_REGNUM);
1451
1452       store_address (buf, 8, faddr);
1453       store_address (buf + 8, 8, global_pointer);
1454
1455       write_memory (fdesc, buf, 16);
1456     }
1457
1458   return fdesc;
1459 }
1460
1461 CORE_ADDR
1462 ia64_push_arguments (int nargs, value_ptr *args, CORE_ADDR sp,
1463                     int struct_return, CORE_ADDR struct_addr)
1464 {
1465   int argno;
1466   value_ptr arg;
1467   struct type *type;
1468   int len, argoffset;
1469   int nslots, rseslots, memslots, slotnum, nfuncargs;
1470   int floatreg;
1471   CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr;
1472
1473   nslots = 0;
1474   nfuncargs = 0;
1475   /* Count the number of slots needed for the arguments */
1476   for (argno = 0; argno < nargs; argno++)
1477     {
1478       arg = args[argno];
1479       type = check_typedef (VALUE_TYPE (arg));
1480       len = TYPE_LENGTH (type);
1481
1482       /* FIXME: This is crude and it is wrong (IMO), but it matches
1483          what gcc does, I think. */
1484       if (len > 8 && (nslots & 1))
1485         nslots++;
1486
1487       if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1488         nfuncargs++;
1489
1490       nslots += (len + 7) / 8;
1491     }
1492
1493   /* Divvy up the slots between the RSE and the memory stack */
1494   rseslots = (nslots > 8) ? 8 : nslots;
1495   memslots = nslots - rseslots;
1496
1497   /* Allocate a new RSE frame */
1498   cfm = read_register (IA64_CFM_REGNUM);
1499
1500   bsp = read_register (IA64_BSP_REGNUM);
1501   bsp = rse_address_add (bsp, cfm & 0x7f);
1502   new_bsp = rse_address_add (bsp, rseslots);
1503   write_register (IA64_BSP_REGNUM, new_bsp);
1504
1505   pfs = read_register (IA64_PFS_REGNUM);
1506   pfs &= 0xc000000000000000LL;
1507   pfs |= (cfm & 0xffffffffffffLL);
1508   write_register (IA64_PFS_REGNUM, pfs);
1509
1510   cfm &= 0xc000000000000000LL;
1511   cfm |= rseslots;
1512   write_register (IA64_CFM_REGNUM, cfm);
1513
1514   /* We will attempt to find function descriptors in the .opd segment,
1515      but if we can't we'll construct them ourselves.  That being the
1516      case, we'll need to reserve space on the stack for them. */
1517   funcdescaddr = sp - nfuncargs * 16;
1518   funcdescaddr &= ~0xfLL;
1519
1520   /* Adjust the stack pointer to it's new value.  The calling conventions
1521      require us to have 16 bytes of scratch, plus whatever space is
1522      necessary for the memory slots and our function descriptors */
1523   sp = sp - 16 - (memslots + nfuncargs) * 8;
1524   sp &= ~0xfLL;                         /* Maintain 16 byte alignment */
1525
1526   /* Place the arguments where they belong.  The arguments will be
1527      either placed in the RSE backing store or on the memory stack.
1528      In addition, floating point arguments or HFAs are placed in
1529      floating point registers. */
1530   slotnum = 0;
1531   floatreg = IA64_FR8_REGNUM;
1532   for (argno = 0; argno < nargs; argno++)
1533     {
1534       struct type *float_elt_type;
1535
1536       arg = args[argno];
1537       type = check_typedef (VALUE_TYPE (arg));
1538       len = TYPE_LENGTH (type);
1539
1540       /* Special handling for function parameters */
1541       if (len == 8
1542           && TYPE_CODE (type) == TYPE_CODE_PTR
1543           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1544         {
1545           char val_buf[8];
1546
1547           store_address (val_buf, 8,
1548             find_func_descr (extract_address (VALUE_CONTENTS (arg), 8),
1549                              &funcdescaddr));
1550           if (slotnum < rseslots)
1551             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1552           else
1553             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1554           slotnum++;
1555           continue;
1556         }
1557
1558       /* Normal slots */
1559       if (len > 8 && (slotnum & 1))
1560         slotnum++;
1561       argoffset = 0;
1562       while (len > 0)
1563         {
1564           char val_buf[8];
1565
1566           memset (val_buf, 0, 8);
1567           memcpy (val_buf, VALUE_CONTENTS (arg) + argoffset, (len > 8) ? 8 : len);
1568
1569           if (slotnum < rseslots)
1570             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1571           else
1572             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1573
1574           argoffset += 8;
1575           len -= 8;
1576           slotnum++;
1577         }
1578
1579       /* Handle floating point types (including HFAs) */
1580       float_elt_type = is_float_or_hfa_type (type);
1581       if (float_elt_type != NULL)
1582         {
1583           argoffset = 0;
1584           len = TYPE_LENGTH (type);
1585           while (len > 0 && floatreg < IA64_FR16_REGNUM)
1586             {
1587               ia64_register_convert_to_raw (
1588                 float_elt_type,
1589                 floatreg,
1590                 VALUE_CONTENTS (arg) + argoffset,
1591                 &registers[REGISTER_BYTE (floatreg)]);
1592               floatreg++;
1593               argoffset += TYPE_LENGTH (float_elt_type);
1594               len -= TYPE_LENGTH (float_elt_type);
1595             }
1596         }
1597     }
1598
1599   /* Store the struct return value in r8 if necessary. */
1600   if (struct_return)
1601     {
1602       store_address (&registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
1603                      REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
1604                      struct_addr);
1605     }
1606
1607   /* Sync gdb's idea of what the registers are with the target. */
1608   target_store_registers (-1);
1609
1610   /* FIXME: This doesn't belong here!  Instead, SAVE_DUMMY_FRAME_TOS needs
1611      to be defined to call generic_save_dummy_frame_tos().  But at the
1612      time of this writing, SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so
1613      I chose to put this call here instead of using the old mechanisms.
1614      Once SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do is add the
1615      line
1616
1617         set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1618
1619      to ia64_gdbarch_init() and remove the line below. */
1620   generic_save_dummy_frame_tos (sp);
1621
1622   return sp;
1623 }
1624
1625 CORE_ADDR
1626 ia64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1627 {
1628   CORE_ADDR global_pointer = find_global_pointer (pc);
1629
1630   if (global_pointer != 0)
1631     write_register (IA64_GR1_REGNUM, global_pointer);
1632
1633   write_register (IA64_BR0_REGNUM, CALL_DUMMY_ADDRESS ());
1634   return sp;
1635 }
1636
1637 void
1638 ia64_store_return_value (struct type *type, char *valbuf)
1639 {
1640   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1641     {
1642       ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
1643                                   &registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
1644       target_store_registers (IA64_FR8_REGNUM);
1645     }
1646   else
1647     write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
1648                           valbuf, TYPE_LENGTH (type));
1649 }
1650
1651 void
1652 ia64_pop_frame (void)
1653 {
1654   generic_pop_current_frame (ia64_pop_frame_regular);
1655 }
1656
1657 static void
1658 ia64_pop_frame_regular (struct frame_info *frame)
1659 {
1660   int regno;
1661   CORE_ADDR bsp, cfm, pfs;
1662
1663   FRAME_INIT_SAVED_REGS (frame);
1664
1665   for (regno = 0; regno < ia64_num_regs; regno++)
1666     {
1667       if (frame->saved_regs[regno]
1668           && (!(IA64_GR32_REGNUM <= regno && regno <= IA64_GR127_REGNUM))
1669           && regno != pc_regnum
1670           && regno != sp_regnum
1671           && regno != IA64_PFS_REGNUM
1672           && regno != IA64_CFM_REGNUM
1673           && regno != IA64_BSP_REGNUM
1674           && regno != IA64_BSPSTORE_REGNUM)
1675         {
1676           write_register (regno,
1677                           read_memory_integer (frame->saved_regs[regno],
1678                                                REGISTER_RAW_SIZE (regno)));
1679         }
1680     }
1681
1682   write_register (sp_regnum, FRAME_CHAIN (frame));
1683   write_pc (FRAME_SAVED_PC (frame));
1684
1685   cfm = read_register (IA64_CFM_REGNUM);
1686
1687   if (frame->saved_regs[IA64_PFS_REGNUM])
1688     {
1689       pfs = read_memory_integer (frame->saved_regs[IA64_PFS_REGNUM],
1690                                  REGISTER_RAW_SIZE (IA64_PFS_REGNUM));
1691     }
1692   else
1693     pfs = read_register (IA64_PFS_REGNUM);
1694
1695   /* Compute the new bsp by *adding* the difference between the
1696      size of the frame and the size of the locals (both wrt the
1697      frame that we're going back to).  This seems kind of strange,
1698      especially since it seems like we ought to be subtracting the
1699      size of the locals... and we should; but the linux kernel
1700      wants bsp to be set at the end of all used registers.  It's
1701      likely that this code will need to be revised to accomodate
1702      other operating systems. */
1703   bsp = rse_address_add (frame->extra_info->bsp,
1704                          (pfs & 0x7f) - ((pfs >> 7) & 0x7f));
1705   write_register (IA64_BSP_REGNUM, bsp);
1706
1707   /* FIXME: What becomes of the epilog count in the PFS? */
1708   cfm = (cfm & ~0xffffffffffffLL) | (pfs & 0xffffffffffffLL);
1709   write_register (IA64_CFM_REGNUM, cfm);
1710
1711   flush_cached_frames ();
1712 }
1713
1714 static void
1715 ia64_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
1716                                     CORE_ADDR *targ_addr, int *targ_len)
1717 {
1718   *targ_addr = memaddr;
1719   *targ_len  = nr_bytes;
1720 }
1721
1722 static struct gdbarch *
1723 ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1724 {
1725   struct gdbarch *gdbarch;
1726
1727   arches = gdbarch_list_lookup_by_info (arches, &info);
1728   if (arches != NULL)
1729     return arches->gdbarch;
1730
1731   gdbarch = gdbarch_alloc (&info, NULL);
1732
1733   set_gdbarch_short_bit (gdbarch, 16);
1734   set_gdbarch_int_bit (gdbarch, 32);
1735   set_gdbarch_long_bit (gdbarch, 64);
1736   set_gdbarch_long_long_bit (gdbarch, 64);
1737   set_gdbarch_float_bit (gdbarch, 32);
1738   set_gdbarch_double_bit (gdbarch, 64);
1739   set_gdbarch_long_double_bit (gdbarch, 64);
1740   set_gdbarch_ptr_bit (gdbarch, 64);
1741
1742   set_gdbarch_num_regs (gdbarch, ia64_num_regs);
1743   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
1744   set_gdbarch_fp_regnum (gdbarch, fp_regnum);
1745   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
1746
1747   set_gdbarch_register_name (gdbarch, ia64_register_name);
1748   set_gdbarch_register_size (gdbarch, 8);
1749   set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
1750   set_gdbarch_register_byte (gdbarch, ia64_register_byte);
1751   set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
1752   set_gdbarch_max_register_raw_size (gdbarch, 16);
1753   set_gdbarch_register_virtual_size (gdbarch, ia64_register_virtual_size);
1754   set_gdbarch_max_register_virtual_size (gdbarch, 16);
1755   set_gdbarch_register_virtual_type (gdbarch, ia64_register_virtual_type);
1756
1757   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
1758
1759   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1760   set_gdbarch_frameless_function_invocation (gdbarch, ia64_frameless_function_invocation);
1761
1762   set_gdbarch_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
1763
1764   set_gdbarch_frame_chain (gdbarch, ia64_frame_chain);
1765   set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
1766   set_gdbarch_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
1767
1768   set_gdbarch_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
1769   set_gdbarch_get_saved_register (gdbarch, ia64_get_saved_register);
1770
1771   set_gdbarch_register_convertible (gdbarch, ia64_register_convertible);
1772   set_gdbarch_register_convert_to_virtual (gdbarch, ia64_register_convert_to_virtual);
1773   set_gdbarch_register_convert_to_raw (gdbarch, ia64_register_convert_to_raw);
1774
1775   set_gdbarch_use_struct_convention (gdbarch, ia64_use_struct_convention);
1776   set_gdbarch_extract_return_value (gdbarch, ia64_extract_return_value);
1777
1778   set_gdbarch_store_struct_return (gdbarch, ia64_store_struct_return);
1779   set_gdbarch_store_return_value (gdbarch, ia64_store_return_value);
1780   set_gdbarch_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
1781
1782   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
1783   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
1784   set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc);
1785   set_gdbarch_read_pc (gdbarch, ia64_read_pc);
1786   set_gdbarch_write_pc (gdbarch, ia64_write_pc);
1787
1788   /* Settings for calling functions in the inferior.  */
1789   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1790   set_gdbarch_call_dummy_length (gdbarch, 0);
1791   set_gdbarch_push_arguments (gdbarch, ia64_push_arguments);
1792   set_gdbarch_push_return_address (gdbarch, ia64_push_return_address);
1793   set_gdbarch_pop_frame (gdbarch, ia64_pop_frame);
1794
1795   set_gdbarch_call_dummy_p (gdbarch, 1);
1796   set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
1797   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
1798   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1799   set_gdbarch_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
1800   set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
1801   set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
1802
1803   /* We won't necessarily have a frame pointer and even if we do,
1804      it winds up being extraordinarly messy when attempting to find
1805      the frame chain.  So for the purposes of creating frames (which
1806      is all read_fp() is used for), simply use the stack pointer value
1807      instead.  */
1808   set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
1809   set_gdbarch_write_fp (gdbarch, generic_target_write_sp);
1810
1811   /* Settings that should be unnecessary.  */
1812   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1813
1814   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
1815   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
1816
1817   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1818   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1819   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1820   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1821   set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
1822   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1823   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1824   set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1825
1826   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1827   set_gdbarch_function_start_offset (gdbarch, 0);
1828
1829   set_gdbarch_remote_translate_xfer_address (
1830     gdbarch, ia64_remote_translate_xfer_address);
1831
1832   return gdbarch;
1833 }
1834
1835 void
1836 _initialize_ia64_tdep (void)
1837 {
1838   register_gdbarch_init (bfd_arch_ia64, ia64_gdbarch_init);
1839
1840   tm_print_insn = print_insn_ia64;
1841   tm_print_insn_info.bytes_per_line = SLOT_MULTIPLIER;
1842 }