gdb/ia64-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2
   3    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   4    2009 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "inferior.h"
  23 #include "gdbcore.h"
  24 #include "arch-utils.h"
  25 #include "floatformat.h"
  26 #include "gdbtypes.h"
  27 #include "regcache.h"
  28 #include "reggroups.h"
  29 #include "frame.h"
  30 #include "frame-base.h"
  31 #include "frame-unwind.h"
  32 #include "doublest.h"
  33 #include "value.h"
  34 #include "gdb_assert.h"
  35 #include "objfiles.h"
  36 #include "elf/common.h"         /* for DT_PLTGOT value */
  37 #include "elf-bfd.h"
  38 #include "dis-asm.h"
  39 #include "infcall.h"
  40 #include "osabi.h"
  41 #include "ia64-tdep.h"
  42 #include "cp-abi.h"
  43
  44 #ifdef HAVE_LIBUNWIND_IA64_H
  45 #include "elf/ia64.h"           /* for PT_IA_64_UNWIND value */
  46 #include "libunwind-frame.h"
  47 #include "libunwind-ia64.h"
  48
  49 /* Note: KERNEL_START is supposed to be an address which is not going
  50          to ever contain any valid unwind info.  For ia64 linux, the choice
  51          of 0xc000000000000000 is fairly safe since that's uncached space.
  52
  53          We use KERNEL_START as follows: after obtaining the kernel's
  54          unwind table via getunwind(), we project its unwind data into
  55          address-range KERNEL_START-(KERNEL_START+ktab_size) and then
  56          when ia64_access_mem() sees a memory access to this
  57          address-range, we redirect it to ktab instead.
  58
  59          None of this hackery is needed with a modern kernel/libcs
  60          which uses the kernel virtual DSO to provide access to the
  61          kernel's unwind info.  In that case, ktab_size remains 0 and
  62          hence the value of KERNEL_START doesn't matter.  */
  63
  64 #define KERNEL_START 0xc000000000000000ULL
  65
  66 static size_t ktab_size = 0;
  67 struct ia64_table_entry
  68   {
  69     uint64_t start_offset;
  70     uint64_t end_offset;
  71     uint64_t info_offset;
  72   };
  73
  74 static struct ia64_table_entry *ktab = NULL;
  75
  76 #endif
  77
  78 /* An enumeration of the different IA-64 instruction types.  */
  79
  80 typedef enum instruction_type
  81 {
  82   A,                    /* Integer ALU ;    I-unit or M-unit */
  83   I,                    /* Non-ALU integer; I-unit */
  84   M,                    /* Memory ;         M-unit */
  85   F,                    /* Floating-point ; F-unit */
  86   B,                    /* Branch ;         B-unit */
  87   L,                    /* Extended (L+X) ; I-unit */
  88   X,                    /* Extended (L+X) ; I-unit */
  89   undefined             /* undefined or reserved */
  90 } instruction_type;
  91
  92 /* We represent IA-64 PC addresses as the value of the instruction
  93    pointer or'd with some bit combination in the low nibble which
  94    represents the slot number in the bundle addressed by the
  95    instruction pointer.  The problem is that the Linux kernel
  96    multiplies its slot numbers (for exceptions) by one while the
  97    disassembler multiplies its slot numbers by 6.  In addition, I've
  98    heard it said that the simulator uses 1 as the multiplier.
  99
 100    I've fixed the disassembler so that the bytes_per_line field will
 101    be the slot multiplier.  If bytes_per_line comes in as zero, it
 102    is set to six (which is how it was set up initially). -- objdump
 103    displays pretty disassembly dumps with this value.  For our purposes,
 104    we'll set bytes_per_line to SLOT_MULTIPLIER. This is okay since we
 105    never want to also display the raw bytes the way objdump does. */
 106
 107 #define SLOT_MULTIPLIER 1
 108
 109 /* Length in bytes of an instruction bundle */
 110
 111 #define BUNDLE_LEN 16
 112
 113 /* See the saved memory layout comment for ia64_memory_insert_breakpoint.  */
 114
 115 #if BREAKPOINT_MAX < BUNDLE_LEN - 2
 116 # error "BREAKPOINT_MAX < BUNDLE_LEN - 2"
 117 #endif
 118
 119 static gdbarch_init_ftype ia64_gdbarch_init;
 120
 121 static gdbarch_register_name_ftype ia64_register_name;
 122 static gdbarch_register_type_ftype ia64_register_type;
 123 static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc;
 124 static gdbarch_skip_prologue_ftype ia64_skip_prologue;
 125 static struct type *is_float_or_hfa_type (struct type *t);
 126 static CORE_ADDR ia64_find_global_pointer (CORE_ADDR faddr);
 127
 128 static struct type *builtin_type_ia64_ext;
 129
 130 #define NUM_IA64_RAW_REGS 462
 131
 132 static int sp_regnum = IA64_GR12_REGNUM;
 133 static int fp_regnum = IA64_VFP_REGNUM;
 134 static int lr_regnum = IA64_VRAP_REGNUM;
 135
 136 /* NOTE: we treat the register stack registers r32-r127 as pseudo-registers because
 137    they may not be accessible via the ptrace register get/set interfaces.  */
 138 enum pseudo_regs { FIRST_PSEUDO_REGNUM = NUM_IA64_RAW_REGS, VBOF_REGNUM = IA64_NAT127_REGNUM + 1, V32_REGNUM,
 139                    V127_REGNUM = V32_REGNUM + 95,
 140                    VP0_REGNUM, VP16_REGNUM = VP0_REGNUM + 16, VP63_REGNUM = VP0_REGNUM + 63, LAST_PSEUDO_REGNUM };
 141
 142 /* Array of register names; There should be ia64_num_regs strings in
 143    the initializer.  */
 144
 145 static char *ia64_register_names[] =
 146 { "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 147   "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 148   "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
 149   "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
 150   "",     "",     "",     "",     "",     "",     "",     "",
 151   "",     "",     "",     "",     "",     "",     "",     "",
 152   "",     "",     "",     "",     "",     "",     "",     "",
 153   "",     "",     "",     "",     "",     "",     "",     "",
 154   "",     "",     "",     "",     "",     "",     "",     "",
 155   "",     "",     "",     "",     "",     "",     "",     "",
 156   "",     "",     "",     "",     "",     "",     "",     "",
 157   "",     "",     "",     "",     "",     "",     "",     "",
 158   "",     "",     "",     "",     "",     "",     "",     "",
 159   "",     "",     "",     "",     "",     "",     "",     "",
 160   "",     "",     "",     "",     "",     "",     "",     "",
 161   "",     "",     "",     "",     "",     "",     "",     "",
 162
 163   "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 164   "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 165   "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 166   "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 167   "f32",  "f33",  "f34",  "f35",  "f36",  "f37",  "f38",  "f39",
 168   "f40",  "f41",  "f42",  "f43",  "f44",  "f45",  "f46",  "f47",
 169   "f48",  "f49",  "f50",  "f51",  "f52",  "f53",  "f54",  "f55",
 170   "f56",  "f57",  "f58",  "f59",  "f60",  "f61",  "f62",  "f63",
 171   "f64",  "f65",  "f66",  "f67",  "f68",  "f69",  "f70",  "f71",
 172   "f72",  "f73",  "f74",  "f75",  "f76",  "f77",  "f78",  "f79",
 173   "f80",  "f81",  "f82",  "f83",  "f84",  "f85",  "f86",  "f87",
 174   "f88",  "f89",  "f90",  "f91",  "f92",  "f93",  "f94",  "f95",
 175   "f96",  "f97",  "f98",  "f99",  "f100", "f101", "f102", "f103",
 176   "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
 177   "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
 178   "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
 179
 180   "",     "",     "",     "",     "",     "",     "",     "",
 181   "",     "",     "",     "",     "",     "",     "",     "",
 182   "",     "",     "",     "",     "",     "",     "",     "",
 183   "",     "",     "",     "",     "",     "",     "",     "",
 184   "",     "",     "",     "",     "",     "",     "",     "",
 185   "",     "",     "",     "",     "",     "",     "",     "",
 186   "",     "",     "",     "",     "",     "",     "",     "",
 187   "",     "",     "",     "",     "",     "",     "",     "",
 188
 189   "b0",   "b1",   "b2",   "b3",   "b4",   "b5",   "b6",   "b7",
 190
 191   "vfp", "vrap",
 192
 193   "pr", "ip", "psr", "cfm",
 194
 195   "kr0",   "kr1",   "kr2",   "kr3",   "kr4",   "kr5",   "kr6",   "kr7",
 196   "", "", "", "", "", "", "", "",
 197   "rsc", "bsp", "bspstore", "rnat",
 198   "", "fcr", "", "",
 199   "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr",  "",
 200   "ccv", "", "", "", "unat", "", "", "",
 201   "fpsr", "", "", "", "itc",
 202   "", "", "", "", "", "", "", "", "", "",
 203   "", "", "", "", "", "", "", "", "",
 204   "pfs", "lc", "ec",
 205   "", "", "", "", "", "", "", "", "", "",
 206   "", "", "", "", "", "", "", "", "", "",
 207   "", "", "", "", "", "", "", "", "", "",
 208   "", "", "", "", "", "", "", "", "", "",
 209   "", "", "", "", "", "", "", "", "", "",
 210   "", "", "", "", "", "", "", "", "", "",
 211   "",
 212   "nat0",  "nat1",  "nat2",  "nat3",  "nat4",  "nat5",  "nat6",  "nat7",
 213   "nat8",  "nat9",  "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
 214   "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
 215   "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
 216   "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
 217   "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
 218   "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
 219   "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
 220   "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
 221   "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
 222   "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
 223   "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
 224   "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
 225   "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
 226   "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
 227   "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
 228
 229   "bof",
 230
 231   "r32",  "r33",  "r34",  "r35",  "r36",  "r37",  "r38",  "r39",
 232   "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
 233   "r48",  "r49",  "r50",  "r51",  "r52",  "r53",  "r54",  "r55",
 234   "r56",  "r57",  "r58",  "r59",  "r60",  "r61",  "r62",  "r63",
 235   "r64",  "r65",  "r66",  "r67",  "r68",  "r69",  "r70",  "r71",
 236   "r72",  "r73",  "r74",  "r75",  "r76",  "r77",  "r78",  "r79",
 237   "r80",  "r81",  "r82",  "r83",  "r84",  "r85",  "r86",  "r87",
 238   "r88",  "r89",  "r90",  "r91",  "r92",  "r93",  "r94",  "r95",
 239   "r96",  "r97",  "r98",  "r99",  "r100", "r101", "r102", "r103",
 240   "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
 241   "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
 242   "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
 243
 244   "p0",   "p1",   "p2",   "p3",   "p4",   "p5",   "p6",   "p7",
 245   "p8",   "p9",   "p10",  "p11",  "p12",  "p13",  "p14",  "p15",
 246   "p16",  "p17",  "p18",  "p19",  "p20",  "p21",  "p22",  "p23",
 247   "p24",  "p25",  "p26",  "p27",  "p28",  "p29",  "p30",  "p31",
 248   "p32",  "p33",  "p34",  "p35",  "p36",  "p37",  "p38",  "p39",
 249   "p40",  "p41",  "p42",  "p43",  "p44",  "p45",  "p46",  "p47",
 250   "p48",  "p49",  "p50",  "p51",  "p52",  "p53",  "p54",  "p55",
 251   "p56",  "p57",  "p58",  "p59",  "p60",  "p61",  "p62",  "p63",
 252 };
 253
 254 struct ia64_frame_cache
 255 {
 256   CORE_ADDR base;       /* frame pointer base for frame */
 257   CORE_ADDR pc;         /* function start pc for frame */
 258   CORE_ADDR saved_sp;   /* stack pointer for frame */
 259   CORE_ADDR bsp;        /* points at r32 for the current frame */
 260   CORE_ADDR cfm;        /* cfm value for current frame */
 261   CORE_ADDR prev_cfm;   /* cfm value for previous frame */
 262   int   frameless;
 263   int   sof;            /* Size of frame  (decoded from cfm value) */
 264   int   sol;            /* Size of locals (decoded from cfm value) */
 265   int   sor;            /* Number of rotating registers. (decoded from cfm value) */
 266   CORE_ADDR after_prologue;
 267   /* Address of first instruction after the last
 268      prologue instruction;  Note that there may
 269      be instructions from the function's body
 270      intermingled with the prologue. */
 271   int mem_stack_frame_size;
 272   /* Size of the memory stack frame (may be zero),
 273      or -1 if it has not been determined yet. */
 274   int   fp_reg;         /* Register number (if any) used a frame pointer
 275                            for this frame.  0 if no register is being used
 276                            as the frame pointer. */
 277
 278   /* Saved registers.  */
 279   CORE_ADDR saved_regs[NUM_IA64_RAW_REGS];
 280
 281 };
 282
 283 static int
 284 ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 285                           struct reggroup *group)
 286 {
 287   int vector_p;
 288   int float_p;
 289   int raw_p;
 290   if (group == all_reggroup)
 291     return 1;
 292   vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
 293   float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
 294   raw_p = regnum < NUM_IA64_RAW_REGS;
 295   if (group == float_reggroup)
 296     return float_p;
 297   if (group == vector_reggroup)
 298     return vector_p;
 299   if (group == general_reggroup)
 300     return (!vector_p && !float_p);
 301   if (group == save_reggroup || group == restore_reggroup)
 302     return raw_p;
 303   return 0;
 304 }
 305
 306 static const char *
 307 ia64_register_name (struct gdbarch *gdbarch, int reg)
 308 {
 309   return ia64_register_names[reg];
 310 }
 311
 312 struct type *
 313 ia64_register_type (struct gdbarch *arch, int reg)
 314 {
 315   if (reg >= IA64_FR0_REGNUM && reg <= IA64_FR127_REGNUM)
 316     return builtin_type_ia64_ext;
 317   else
 318     return builtin_type (arch)->builtin_long;
 319 }
 320
 321 static int
 322 ia64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 323 {
 324   if (reg >= IA64_GR32_REGNUM && reg <= IA64_GR127_REGNUM)
 325     return V32_REGNUM + (reg - IA64_GR32_REGNUM);
 326   return reg;
 327 }
 328
 329 static int
 330 floatformat_valid (const struct floatformat *fmt, const void *from)
 331 {
 332   return 1;
 333 }
 334
 335 const struct floatformat floatformat_ia64_ext =
 336 {
 337   floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 338   floatformat_intbit_yes, "floatformat_ia64_ext", floatformat_valid, NULL
 339 };
 340
 341 const struct floatformat *floatformats_ia64_ext[2] =
 342 {
 343   &floatformat_ia64_ext,
 344   &floatformat_ia64_ext
 345 };
 346
 347
 348 /* Extract ``len'' bits from an instruction bundle starting at
 349    bit ``from''.  */
 350
 351 static long long
 352 extract_bit_field (const char *bundle, int from, int len)
 353 {
 354   long long result = 0LL;
 355   int to = from + len;
 356   int from_byte = from / 8;
 357   int to_byte = to / 8;
 358   unsigned char *b = (unsigned char *) bundle;
 359   unsigned char c;
 360   int lshift;
 361   int i;
 362
 363   c = b[from_byte];
 364   if (from_byte == to_byte)
 365     c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
 366   result = c >> (from % 8);
 367   lshift = 8 - (from % 8);
 368
 369   for (i = from_byte+1; i < to_byte; i++)
 370     {
 371       result |= ((long long) b[i]) << lshift;
 372       lshift += 8;
 373     }
 374
 375   if (from_byte < to_byte && (to % 8 != 0))
 376     {
 377       c = b[to_byte];
 378       c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
 379       result |= ((long long) c) << lshift;
 380     }
 381
 382   return result;
 383 }
 384
 385 /* Replace the specified bits in an instruction bundle */
 386
 387 static void
 388 replace_bit_field (char *bundle, long long val, int from, int len)
 389 {
 390   int to = from + len;
 391   int from_byte = from / 8;
 392   int to_byte = to / 8;
 393   unsigned char *b = (unsigned char *) bundle;
 394   unsigned char c;
 395
 396   if (from_byte == to_byte)
 397     {
 398       unsigned char left, right;
 399       c = b[from_byte];
 400       left = (c >> (to % 8)) << (to % 8);
 401       right = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
 402       c = (unsigned char) (val & 0xff);
 403       c = (unsigned char) (c << (from % 8 + 8 - to % 8)) >> (8 - to % 8);
 404       c |= right | left;
 405       b[from_byte] = c;
 406     }
 407   else
 408     {
 409       int i;
 410       c = b[from_byte];
 411       c = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
 412       c = c | (val << (from % 8));
 413       b[from_byte] = c;
 414       val >>= 8 - from % 8;
 415
 416       for (i = from_byte+1; i < to_byte; i++)
 417         {
 418           c = val & 0xff;
 419           val >>= 8;
 420           b[i] = c;
 421         }
 422
 423       if (to % 8 != 0)
 424         {
 425           unsigned char cv = (unsigned char) val;
 426           c = b[to_byte];
 427           c = c >> (to % 8) << (to % 8);
 428           c |= ((unsigned char) (cv << (8 - to % 8))) >> (8 - to % 8);
 429           b[to_byte] = c;
 430         }
 431     }
 432 }
 433
 434 /* Return the contents of slot N (for N = 0, 1, or 2) in
 435    and instruction bundle */
 436
 437 static long long
 438 slotN_contents (char *bundle, int slotnum)
 439 {
 440   return extract_bit_field (bundle, 5+41*slotnum, 41);
 441 }
 442
 443 /* Store an instruction in an instruction bundle */
 444
 445 static void
 446 replace_slotN_contents (char *bundle, long long instr, int slotnum)
 447 {
 448   replace_bit_field (bundle, instr, 5+41*slotnum, 41);
 449 }
 450
 451 static const enum instruction_type template_encoding_table[32][3] =
 452 {
 453   { M, I, I },                          /* 00 */
 454   { M, I, I },                          /* 01 */
 455   { M, I, I },                          /* 02 */
 456   { M, I, I },                          /* 03 */
 457   { M, L, X },                          /* 04 */
 458   { M, L, X },                          /* 05 */
 459   { undefined, undefined, undefined },  /* 06 */
 460   { undefined, undefined, undefined },  /* 07 */
 461   { M, M, I },                          /* 08 */
 462   { M, M, I },                          /* 09 */
 463   { M, M, I },                          /* 0A */
 464   { M, M, I },                          /* 0B */
 465   { M, F, I },                          /* 0C */
 466   { M, F, I },                          /* 0D */
 467   { M, M, F },                          /* 0E */
 468   { M, M, F },                          /* 0F */
 469   { M, I, B },                          /* 10 */
 470   { M, I, B },                          /* 11 */
 471   { M, B, B },                          /* 12 */
 472   { M, B, B },                          /* 13 */
 473   { undefined, undefined, undefined },  /* 14 */
 474   { undefined, undefined, undefined },  /* 15 */
 475   { B, B, B },                          /* 16 */
 476   { B, B, B },                          /* 17 */
 477   { M, M, B },                          /* 18 */
 478   { M, M, B },                          /* 19 */
 479   { undefined, undefined, undefined },  /* 1A */
 480   { undefined, undefined, undefined },  /* 1B */
 481   { M, F, B },                          /* 1C */
 482   { M, F, B },                          /* 1D */
 483   { undefined, undefined, undefined },  /* 1E */
 484   { undefined, undefined, undefined },  /* 1F */
 485 };
 486
 487 /* Fetch and (partially) decode an instruction at ADDR and return the
 488    address of the next instruction to fetch.  */
 489
 490 static CORE_ADDR
 491 fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr)
 492 {
 493   char bundle[BUNDLE_LEN];
 494   int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
 495   long long template;
 496   int val;
 497
 498   /* Warn about slot numbers greater than 2.  We used to generate
 499      an error here on the assumption that the user entered an invalid
 500      address.  But, sometimes GDB itself requests an invalid address.
 501      This can (easily) happen when execution stops in a function for
 502      which there are no symbols.  The prologue scanner will attempt to
 503      find the beginning of the function - if the nearest symbol
 504      happens to not be aligned on a bundle boundary (16 bytes), the
 505      resulting starting address will cause GDB to think that the slot
 506      number is too large.
 507
 508      So we warn about it and set the slot number to zero.  It is
 509      not necessarily a fatal condition, particularly if debugging
 510      at the assembly language level.  */
 511   if (slotnum > 2)
 512     {
 513       warning (_("Can't fetch instructions for slot numbers greater than 2.\n"
 514                "Using slot 0 instead"));
 515       slotnum = 0;
 516     }
 517
 518   addr &= ~0x0f;
 519
 520   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 521
 522   if (val != 0)
 523     return 0;
 524
 525   *instr = slotN_contents (bundle, slotnum);
 526   template = extract_bit_field (bundle, 0, 5);
 527   *it = template_encoding_table[(int)template][slotnum];
 528
 529   if (slotnum == 2 || (slotnum == 1 && *it == L))
 530     addr += 16;
 531   else
 532     addr += (slotnum + 1) * SLOT_MULTIPLIER;
 533
 534   return addr;
 535 }
 536
 537 /* There are 5 different break instructions (break.i, break.b,
 538    break.m, break.f, and break.x), but they all have the same
 539    encoding.  (The five bit template in the low five bits of the
 540    instruction bundle distinguishes one from another.)
 541
 542    The runtime architecture manual specifies that break instructions
 543    used for debugging purposes must have the upper two bits of the 21
 544    bit immediate set to a 0 and a 1 respectively.  A breakpoint
 545    instruction encodes the most significant bit of its 21 bit
 546    immediate at bit 36 of the 41 bit instruction.  The penultimate msb
 547    is at bit 25 which leads to the pattern below.
 548
 549    Originally, I had this set up to do, e.g, a "break.i 0x80000"  But
 550    it turns out that 0x80000 was used as the syscall break in the early
 551    simulators.  So I changed the pattern slightly to do "break.i 0x080001"
 552    instead.  But that didn't work either (I later found out that this
 553    pattern was used by the simulator that I was using.)  So I ended up
 554    using the pattern seen below.
 555
 556    SHADOW_CONTENTS has byte-based addressing (PLACED_ADDRESS and SHADOW_LEN)
 557    while we need bit-based addressing as the instructions length is 41 bits and
 558    we must not modify/corrupt the adjacent slots in the same bundle.
 559    Fortunately we may store larger memory incl. the adjacent bits with the
 560    original memory content (not the possibly already stored breakpoints there).
 561    We need to be careful in ia64_memory_remove_breakpoint to always restore
 562    only the specific bits of this instruction ignoring any adjacent stored
 563    bits.
 564
 565    We use the original addressing with the low nibble in the range <0..2> which
 566    gets incorrectly interpreted by generic non-ia64 breakpoint_restore_shadows
 567    as the direct byte offset of SHADOW_CONTENTS.  We store whole BUNDLE_LEN
 568    bytes just without these two possibly skipped bytes to not to exceed to the
 569    next bundle.
 570
 571    If we would like to store the whole bundle to SHADOW_CONTENTS we would have
 572    to store already the base address (`address & ~0x0f') into PLACED_ADDRESS.
 573    In such case there is no other place where to store
 574    SLOTNUM (`adress & 0x0f', value in the range <0..2>).  We need to know
 575    SLOTNUM in ia64_memory_remove_breakpoint.
 576
 577    ia64 16-byte bundle layout:
 578    | 5 bits | slot 0 with 41 bits | slot 1 with 41 bits | slot 2 with 41 bits |
 579
 580    The current addressing used by the code below:
 581    original PC   placed_address   placed_size             required    covered
 582                                   == bp_tgt->shadow_len   reqd \subset covered
 583    0xABCDE0      0xABCDE0         0xE                     <0x0...0x5> <0x0..0xD>
 584    0xABCDE1      0xABCDE1         0xE                     <0x5...0xA> <0x1..0xE>
 585    0xABCDE2      0xABCDE2         0xE                     <0xA...0xF> <0x2..0xF>
 586
 587    `objdump -d' and some other tools show a bit unjustified offsets:
 588    original PC   byte where starts the instruction   objdump offset
 589    0xABCDE0      0xABCDE0                            0xABCDE0
 590    0xABCDE1      0xABCDE5                            0xABCDE6
 591    0xABCDE2      0xABCDEA                            0xABCDEC
 592    */
 593
 594 #define IA64_BREAKPOINT 0x00003333300LL
 595
 596 static int
 597 ia64_memory_insert_breakpoint (struct gdbarch *gdbarch,
 598                                struct bp_target_info *bp_tgt)
 599 {
 600   CORE_ADDR addr = bp_tgt->placed_address;
 601   gdb_byte bundle[BUNDLE_LEN];
 602   int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
 603   long long instr_breakpoint;
 604   int val;
 605   int template;
 606   struct cleanup *cleanup;
 607
 608   if (slotnum > 2)
 609     error (_("Can't insert breakpoint for slot numbers greater than 2."));
 610
 611   addr &= ~0x0f;
 612
 613   /* Disable the automatic memory restoration from breakpoints while
 614      we read our instruction bundle.  Otherwise, the general restoration
 615      mechanism kicks in and we would possibly remove parts of the adjacent
 616      placed breakpoints.  It is due to our SHADOW_CONTENTS overlapping the real
 617      breakpoint instruction bits region.  */
 618   cleanup = make_show_memory_breakpoints_cleanup (1);
 619   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 620
 621   /* Check for L type instruction in slot 1, if present then bump up the slot
 622      number to the slot 2.  */
 623   template = extract_bit_field (bundle, 0, 5);
 624   if (slotnum == 1 && template_encoding_table[template][slotnum] == L)
 625     slotnum = 2;
 626
 627   /* Slot number 2 may skip at most 2 bytes at the beginning.  */
 628   bp_tgt->placed_size = bp_tgt->shadow_len = BUNDLE_LEN - 2;
 629
 630   /* Store the whole bundle, except for the initial skipped bytes by the slot
 631      number interpreted as bytes offset in PLACED_ADDRESS.  */
 632   memcpy (bp_tgt->shadow_contents, bundle + slotnum, bp_tgt->shadow_len);
 633
 634   /* Breakpoints already present in the code will get deteacted and not get
 635      reinserted by bp_loc_is_permanent.  Multiple breakpoints at the same
 636      location cannot induce the internal error as they are optimized into
 637      a single instance by update_global_location_list.  */
 638   instr_breakpoint = slotN_contents (bundle, slotnum);
 639   if (instr_breakpoint == IA64_BREAKPOINT)
 640     internal_error (__FILE__, __LINE__,
 641                     _("Address %s already contains a breakpoint."),
 642                     paddr_nz (bp_tgt->placed_address));
 643   replace_slotN_contents (bundle, IA64_BREAKPOINT, slotnum);
 644
 645   if (val == 0)
 646     val = target_write_memory (addr + slotnum, bundle + slotnum,
 647                                bp_tgt->shadow_len);
 648
 649   do_cleanups (cleanup);
 650   return val;
 651 }
 652
 653 static int
 654 ia64_memory_remove_breakpoint (struct gdbarch *gdbarch,
 655                                struct bp_target_info *bp_tgt)
 656 {
 657   CORE_ADDR addr = bp_tgt->placed_address;
 658   gdb_byte bundle_mem[BUNDLE_LEN], bundle_saved[BUNDLE_LEN];
 659   int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER;
 660   long long instr_breakpoint, instr_saved;
 661   int val;
 662   int template;
 663   struct cleanup *cleanup;
 664
 665   addr &= ~0x0f;
 666
 667   /* Disable the automatic memory restoration from breakpoints while
 668      we read our instruction bundle.  Otherwise, the general restoration
 669      mechanism kicks in and we would possibly remove parts of the adjacent
 670      placed breakpoints.  It is due to our SHADOW_CONTENTS overlapping the real
 671      breakpoint instruction bits region.  */
 672   cleanup = make_show_memory_breakpoints_cleanup (1);
 673   val = target_read_memory (addr, bundle_mem, BUNDLE_LEN);
 674
 675   /* Check for L type instruction in slot 1, if present then bump up the slot
 676      number to the slot 2.  */
 677   template = extract_bit_field (bundle_mem, 0, 5);
 678   if (slotnum == 1 && template_encoding_table[template][slotnum] == L)
 679     slotnum = 2;
 680
 681   gdb_assert (bp_tgt->placed_size == BUNDLE_LEN - 2);
 682   gdb_assert (bp_tgt->placed_size == bp_tgt->shadow_len);
 683
 684   instr_breakpoint = slotN_contents (bundle_mem, slotnum);
 685   if (instr_breakpoint != IA64_BREAKPOINT)
 686     {
 687       warning (_("Cannot remove breakpoint at address %s, "
 688                  "no break instruction at such address."),
 689                paddr_nz (bp_tgt->placed_address));
 690       return -1;
 691     }
 692
 693   /* Extract the original saved instruction from SLOTNUM normalizing its
 694      bit-shift for INSTR_SAVED.  */
 695   memcpy (bundle_saved, bundle_mem, BUNDLE_LEN);
 696   memcpy (bundle_saved + slotnum, bp_tgt->shadow_contents, bp_tgt->shadow_len);
 697   instr_saved = slotN_contents (bundle_saved, slotnum);
 698
 699   /* In BUNDLE_MEM be careful to modify only the bits belonging to SLOTNUM and
 700      never any other possibly also stored in SHADOW_CONTENTS.  */
 701   replace_slotN_contents (bundle_mem, instr_saved, slotnum);
 702   if (val == 0)
 703     val = target_write_memory (addr, bundle_mem, BUNDLE_LEN);
 704
 705   do_cleanups (cleanup);
 706   return val;
 707 }
 708
 709 /* As gdbarch_breakpoint_from_pc ranges have byte granularity and ia64
 710    instruction slots ranges are bit-granular (41 bits) we have to provide an
 711    extended range as described for ia64_memory_insert_breakpoint.  We also take
 712    care of preserving the `break' instruction 21-bit (or 62-bit) parameter to
 713    make a match for permanent breakpoints.  */
 714
 715 static const gdb_byte *
 716 ia64_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 717 {
 718   CORE_ADDR addr = *pcptr;
 719   static gdb_byte bundle[BUNDLE_LEN];
 720   int slotnum = (int) (*pcptr & 0x0f) / SLOT_MULTIPLIER;
 721   long long instr_fetched;
 722   int val;
 723   int template;
 724   struct cleanup *cleanup;
 725
 726   if (slotnum > 2)
 727     error (_("Can't insert breakpoint for slot numbers greater than 2."));
 728
 729   addr &= ~0x0f;
 730
 731   /* Enable the automatic memory restoration from breakpoints while
 732      we read our instruction bundle to match bp_loc_is_permanent.  */
 733   cleanup = make_show_memory_breakpoints_cleanup (0);
 734   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 735   do_cleanups (cleanup);
 736
 737   /* The memory might be unreachable.  This can happen, for instance,
 738      when the user inserts a breakpoint at an invalid address.  */
 739   if (val != 0)
 740     return NULL;
 741
 742   /* Check for L type instruction in slot 1, if present then bump up the slot
 743      number to the slot 2.  */
 744   template = extract_bit_field (bundle, 0, 5);
 745   if (slotnum == 1 && template_encoding_table[template][slotnum] == L)
 746     slotnum = 2;
 747
 748   /* A break instruction has its all its opcode bits cleared except for
 749      the parameter value.  For L+X slot pair we are at the X slot (slot 2) so
 750      we should not touch the L slot - the upper 41 bits of the parameter.  */
 751   instr_fetched = slotN_contents (bundle, slotnum);
 752   instr_fetched &= 0x1003ffffc0LL;
 753   replace_slotN_contents (bundle, instr_fetched, slotnum);
 754
 755   *lenptr = BUNDLE_LEN - 2;
 756
 757   /* SLOTNUM is possibly already locally modified - use caller's *PCPTR.  */
 758   return bundle + (*pcptr & 0x0f);
 759 }
 760
 761 static CORE_ADDR
 762 ia64_read_pc (struct regcache *regcache)
 763 {
 764   ULONGEST psr_value, pc_value;
 765   int slot_num;
 766
 767   regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value);
 768   regcache_cooked_read_unsigned (regcache, IA64_IP_REGNUM, &pc_value);
 769   slot_num = (psr_value >> 41) & 3;
 770
 771   return pc_value | (slot_num * SLOT_MULTIPLIER);
 772 }
 773
 774 void
 775 ia64_write_pc (struct regcache *regcache, CORE_ADDR new_pc)
 776 {
 777   int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
 778   ULONGEST psr_value;
 779
 780   regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value);
 781   psr_value &= ~(3LL << 41);
 782   psr_value |= (ULONGEST)(slot_num & 0x3) << 41;
 783
 784   new_pc &= ~0xfLL;
 785
 786   regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr_value);
 787   regcache_cooked_write_unsigned (regcache, IA64_IP_REGNUM, new_pc);
 788 }
 789
 790 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
 791
 792 /* Returns the address of the slot that's NSLOTS slots away from
 793    the address ADDR. NSLOTS may be positive or negative. */
 794 static CORE_ADDR
 795 rse_address_add(CORE_ADDR addr, int nslots)
 796 {
 797   CORE_ADDR new_addr;
 798   int mandatory_nat_slots = nslots / 63;
 799   int direction = nslots < 0 ? -1 : 1;
 800
 801   new_addr = addr + 8 * (nslots + mandatory_nat_slots);
 802
 803   if ((new_addr >> 9)  != ((addr + 8 * 64 * mandatory_nat_slots) >> 9))
 804     new_addr += 8 * direction;
 805
 806   if (IS_NaT_COLLECTION_ADDR(new_addr))
 807     new_addr += 8 * direction;
 808
 809   return new_addr;
 810 }
 811
 812 static void
 813 ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 814                            int regnum, gdb_byte *buf)
 815 {
 816   if (regnum >= V32_REGNUM && regnum <= V127_REGNUM)
 817     {
 818 #ifdef HAVE_LIBUNWIND_IA64_H
 819       /* First try and use the libunwind special reg accessor, otherwise fallback to
 820          standard logic.  */
 821       if (!libunwind_is_initialized ()
 822           || libunwind_get_reg_special (gdbarch, regcache, regnum, buf) != 0)
 823 #endif
 824         {
 825           /* The fallback position is to assume that r32-r127 are found sequentially
 826              in memory starting at $bof.  This isn't always true, but without libunwind,
 827              this is the best we can do.  */
 828           ULONGEST cfm;
 829           ULONGEST bsp;
 830           CORE_ADDR reg;
 831           regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
 832           regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 833
 834           /* The bsp points at the end of the register frame so we
 835              subtract the size of frame from it to get start of register frame.  */
 836           bsp = rse_address_add (bsp, -(cfm & 0x7f));
 837
 838           if ((cfm & 0x7f) > regnum - V32_REGNUM)
 839             {
 840               ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
 841               reg = read_memory_integer ((CORE_ADDR)reg_addr, 8);
 842               store_unsigned_integer (buf, register_size (gdbarch, regnum), reg);
 843             }
 844           else
 845             store_unsigned_integer (buf, register_size (gdbarch, regnum), 0);
 846         }
 847     }
 848   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
 849     {
 850       ULONGEST unatN_val;
 851       ULONGEST unat;
 852       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
 853       unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0;
 854       store_unsigned_integer (buf, register_size (gdbarch, regnum), unatN_val);
 855     }
 856   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
 857     {
 858       ULONGEST natN_val = 0;
 859       ULONGEST bsp;
 860       ULONGEST cfm;
 861       CORE_ADDR gr_addr = 0;
 862       regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
 863       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 864
 865       /* The bsp points at the end of the register frame so we
 866          subtract the size of frame from it to get start of register frame.  */
 867       bsp = rse_address_add (bsp, -(cfm & 0x7f));
 868
 869       if ((cfm & 0x7f) > regnum - V32_REGNUM)
 870         gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
 871
 872       if (gr_addr != 0)
 873         {
 874           /* Compute address of nat collection bits.  */
 875           CORE_ADDR nat_addr = gr_addr | 0x1f8;
 876           CORE_ADDR nat_collection;
 877           int nat_bit;
 878           /* If our nat collection address is bigger than bsp, we have to get
 879              the nat collection from rnat.  Otherwise, we fetch the nat
 880              collection from the computed address.  */
 881           if (nat_addr >= bsp)
 882             regcache_cooked_read_unsigned (regcache, IA64_RNAT_REGNUM, &nat_collection);
 883           else
 884             nat_collection = read_memory_integer (nat_addr, 8);
 885           nat_bit = (gr_addr >> 3) & 0x3f;
 886           natN_val = (nat_collection >> nat_bit) & 1;
 887         }
 888
 889       store_unsigned_integer (buf, register_size (gdbarch, regnum), natN_val);
 890     }
 891   else if (regnum == VBOF_REGNUM)
 892     {
 893       /* A virtual register frame start is provided for user convenience.
 894          It can be calculated as the bsp - sof (sizeof frame). */
 895       ULONGEST bsp, vbsp;
 896       ULONGEST cfm;
 897       CORE_ADDR reg;
 898       regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
 899       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 900
 901       /* The bsp points at the end of the register frame so we
 902          subtract the size of frame from it to get beginning of frame.  */
 903       vbsp = rse_address_add (bsp, -(cfm & 0x7f));
 904       store_unsigned_integer (buf, register_size (gdbarch, regnum), vbsp);
 905     }
 906   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
 907     {
 908       ULONGEST pr;
 909       ULONGEST cfm;
 910       ULONGEST prN_val;
 911       CORE_ADDR reg;
 912       regcache_cooked_read_unsigned (regcache, IA64_PR_REGNUM, &pr);
 913       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 914
 915       if (VP16_REGNUM <= regnum && regnum <= VP63_REGNUM)
 916         {
 917           /* Fetch predicate register rename base from current frame
 918              marker for this frame. */
 919           int rrb_pr = (cfm >> 32) & 0x3f;
 920
 921           /* Adjust the register number to account for register rotation. */
 922           regnum = VP16_REGNUM
 923                  + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
 924         }
 925       prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0;
 926       store_unsigned_integer (buf, register_size (gdbarch, regnum), prN_val);
 927     }
 928   else
 929     memset (buf, 0, register_size (gdbarch, regnum));
 930 }
 931
 932 static void
 933 ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 934                             int regnum, const gdb_byte *buf)
 935 {
 936   if (regnum >= V32_REGNUM && regnum <= V127_REGNUM)
 937     {
 938       ULONGEST bsp;
 939       ULONGEST cfm;
 940       CORE_ADDR reg;
 941       regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
 942       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 943
 944       bsp = rse_address_add (bsp, -(cfm & 0x7f));
 945
 946       if ((cfm & 0x7f) > regnum - V32_REGNUM)
 947         {
 948           ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
 949           write_memory (reg_addr, (void *)buf, 8);
 950         }
 951     }
 952   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
 953     {
 954       ULONGEST unatN_val, unat, unatN_mask;
 955       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
 956       unatN_val = extract_unsigned_integer (buf, register_size (gdbarch, regnum));
 957       unatN_mask = (1LL << (regnum - IA64_NAT0_REGNUM));
 958       if (unatN_val == 0)
 959         unat &= ~unatN_mask;
 960       else if (unatN_val == 1)
 961         unat |= unatN_mask;
 962       regcache_cooked_write_unsigned (regcache, IA64_UNAT_REGNUM, unat);
 963     }
 964   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
 965     {
 966       ULONGEST natN_val;
 967       ULONGEST bsp;
 968       ULONGEST cfm;
 969       CORE_ADDR gr_addr = 0;
 970       regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
 971       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 972
 973       /* The bsp points at the end of the register frame so we
 974          subtract the size of frame from it to get start of register frame.  */
 975       bsp = rse_address_add (bsp, -(cfm & 0x7f));
 976
 977       if ((cfm & 0x7f) > regnum - V32_REGNUM)
 978         gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
 979
 980       natN_val = extract_unsigned_integer (buf, register_size (gdbarch, regnum));
 981
 982       if (gr_addr != 0 && (natN_val == 0 || natN_val == 1))
 983         {
 984           /* Compute address of nat collection bits.  */
 985           CORE_ADDR nat_addr = gr_addr | 0x1f8;
 986           CORE_ADDR nat_collection;
 987           int natN_bit = (gr_addr >> 3) & 0x3f;
 988           ULONGEST natN_mask = (1LL << natN_bit);
 989           /* If our nat collection address is bigger than bsp, we have to get
 990              the nat collection from rnat.  Otherwise, we fetch the nat
 991              collection from the computed address.  */
 992           if (nat_addr >= bsp)
 993             {
 994               regcache_cooked_read_unsigned (regcache, IA64_RNAT_REGNUM, &nat_collection);
 995               if (natN_val)
 996                 nat_collection |= natN_mask;
 997               else
 998                 nat_collection &= ~natN_mask;
 999               regcache_cooked_write_unsigned (regcache, IA64_RNAT_REGNUM, nat_collection);
1000             }
1001           else
1002             {
1003               char nat_buf[8];
1004               nat_collection = read_memory_integer (nat_addr, 8);
1005               if (natN_val)
1006                 nat_collection |= natN_mask;
1007               else
1008                 nat_collection &= ~natN_mask;
1009               store_unsigned_integer (nat_buf, register_size (gdbarch, regnum), nat_collection);
1010               write_memory (nat_addr, nat_buf, 8);
1011             }
1012         }
1013     }
1014   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
1015     {
1016       ULONGEST pr;
1017       ULONGEST cfm;
1018       ULONGEST prN_val;
1019       ULONGEST prN_mask;
1020
1021       regcache_cooked_read_unsigned (regcache, IA64_PR_REGNUM, &pr);
1022       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
1023
1024       if (VP16_REGNUM <= regnum && regnum <= VP63_REGNUM)
1025         {
1026           /* Fetch predicate register rename base from current frame
1027              marker for this frame. */
1028           int rrb_pr = (cfm >> 32) & 0x3f;
1029
1030           /* Adjust the register number to account for register rotation. */
1031           regnum = VP16_REGNUM
1032                  + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
1033         }
1034       prN_val = extract_unsigned_integer (buf, register_size (gdbarch, regnum));
1035       prN_mask = (1LL << (regnum - VP0_REGNUM));
1036       if (prN_val == 0)
1037         pr &= ~prN_mask;
1038       else if (prN_val == 1)
1039         pr |= prN_mask;
1040       regcache_cooked_write_unsigned (regcache, IA64_PR_REGNUM, pr);
1041     }
1042 }
1043
1044 /* The ia64 needs to convert between various ieee floating-point formats
1045    and the special ia64 floating point register format.  */
1046
1047 static int
1048 ia64_convert_register_p (struct gdbarch *gdbarch, int regno, struct type *type)
1049 {
1050   return (regno >= IA64_FR0_REGNUM && regno <= IA64_FR127_REGNUM
1051           && type != builtin_type_ia64_ext);
1052 }
1053
1054 static void
1055 ia64_register_to_value (struct frame_info *frame, int regnum,
1056                          struct type *valtype, gdb_byte *out)
1057 {
1058   char in[MAX_REGISTER_SIZE];
1059   frame_register_read (frame, regnum, in);
1060   convert_typed_floating (in, builtin_type_ia64_ext, out, valtype);
1061 }
1062
1063 static void
1064 ia64_value_to_register (struct frame_info *frame, int regnum,
1065                          struct type *valtype, const gdb_byte *in)
1066 {
1067   char out[MAX_REGISTER_SIZE];
1068   convert_typed_floating (in, valtype, out, builtin_type_ia64_ext);
1069   put_frame_register (frame, regnum, out);
1070 }
1071
1072
1073 /* Limit the number of skipped non-prologue instructions since examining
1074    of the prologue is expensive.  */
1075 static int max_skip_non_prologue_insns = 40;
1076
1077 /* Given PC representing the starting address of a function, and
1078    LIM_PC which is the (sloppy) limit to which to scan when looking
1079    for a prologue, attempt to further refine this limit by using
1080    the line data in the symbol table.  If successful, a better guess
1081    on where the prologue ends is returned, otherwise the previous
1082    value of lim_pc is returned.  TRUST_LIMIT is a pointer to a flag
1083    which will be set to indicate whether the returned limit may be
1084    used with no further scanning in the event that the function is
1085    frameless.  */
1086
1087 /* FIXME: cagney/2004-02-14: This function and logic have largely been
1088    superseded by skip_prologue_using_sal.  */
1089
1090 static CORE_ADDR
1091 refine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc, int *trust_limit)
1092 {
1093   struct symtab_and_line prologue_sal;
1094   CORE_ADDR start_pc = pc;
1095   CORE_ADDR end_pc;
1096
1097   /* The prologue can not possibly go past the function end itself,
1098      so we can already adjust LIM_PC accordingly.  */
1099   if (find_pc_partial_function (pc, NULL, NULL, &end_pc) && end_pc < lim_pc)
1100     lim_pc = end_pc;
1101
1102   /* Start off not trusting the limit.  */
1103   *trust_limit = 0;
1104
1105   prologue_sal = find_pc_line (pc, 0);
1106   if (prologue_sal.line != 0)
1107     {
1108       int i;
1109       CORE_ADDR addr = prologue_sal.end;
1110
1111       /* Handle the case in which compiler's optimizer/scheduler
1112          has moved instructions into the prologue.  We scan ahead
1113          in the function looking for address ranges whose corresponding
1114          line number is less than or equal to the first one that we
1115          found for the function.  (It can be less than when the
1116          scheduler puts a body instruction before the first prologue
1117          instruction.)  */
1118       for (i = 2 * max_skip_non_prologue_insns;
1119            i > 0 && (lim_pc == 0 || addr < lim_pc);
1120            i--)
1121         {
1122           struct symtab_and_line sal;
1123
1124           sal = find_pc_line (addr, 0);
1125           if (sal.line == 0)
1126             break;
1127           if (sal.line <= prologue_sal.line
1128               && sal.symtab == prologue_sal.symtab)
1129             {
1130               prologue_sal = sal;
1131             }
1132           addr = sal.end;
1133         }
1134
1135       if (lim_pc == 0 || prologue_sal.end < lim_pc)
1136         {
1137           lim_pc = prologue_sal.end;
1138           if (start_pc == get_pc_function_start (lim_pc))
1139             *trust_limit = 1;
1140         }
1141     }
1142   return lim_pc;
1143 }
1144
1145 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
1146   || (8 <= (_regnum_) && (_regnum_) <= 11) \
1147   || (14 <= (_regnum_) && (_regnum_) <= 31))
1148 #define imm9(_instr_) \
1149   ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
1150    | (((_instr_) & 0x00008000000LL) >> 20) \
1151    | (((_instr_) & 0x00000001fc0LL) >> 6))
1152
1153 /* Allocate and initialize a frame cache.  */
1154
1155 static struct ia64_frame_cache *
1156 ia64_alloc_frame_cache (void)
1157 {
1158   struct ia64_frame_cache *cache;
1159   int i;
1160
1161   cache = FRAME_OBSTACK_ZALLOC (struct ia64_frame_cache);
1162
1163   /* Base address.  */
1164   cache->base = 0;
1165   cache->pc = 0;
1166   cache->cfm = 0;
1167   cache->prev_cfm = 0;
1168   cache->sof = 0;
1169   cache->sol = 0;
1170   cache->sor = 0;
1171   cache->bsp = 0;
1172   cache->fp_reg = 0;
1173   cache->frameless = 1;
1174
1175   for (i = 0; i < NUM_IA64_RAW_REGS; i++)
1176     cache->saved_regs[i] = 0;
1177
1178   return cache;
1179 }
1180
1181 static CORE_ADDR
1182 examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc,
1183                   struct frame_info *this_frame,
1184                   struct ia64_frame_cache *cache)
1185 {
1186   CORE_ADDR next_pc;
1187   CORE_ADDR last_prologue_pc = pc;
1188   instruction_type it;
1189   long long instr;
1190   int cfm_reg  = 0;
1191   int ret_reg  = 0;
1192   int fp_reg   = 0;
1193   int unat_save_reg = 0;
1194   int pr_save_reg = 0;
1195   int mem_stack_frame_size = 0;
1196   int spill_reg   = 0;
1197   CORE_ADDR spill_addr = 0;
1198   char instores[8];
1199   char infpstores[8];
1200   char reg_contents[256];
1201   int trust_limit;
1202   int frameless = 1;
1203   int i;
1204   CORE_ADDR addr;
1205   char buf[8];
1206   CORE_ADDR bof, sor, sol, sof, cfm, rrb_gr;
1207
1208   memset (instores, 0, sizeof instores);
1209   memset (infpstores, 0, sizeof infpstores);
1210   memset (reg_contents, 0, sizeof reg_contents);
1211
1212   if (cache->after_prologue != 0
1213       && cache->after_prologue <= lim_pc)
1214     return cache->after_prologue;
1215
1216   lim_pc = refine_prologue_limit (pc, lim_pc, &trust_limit);
1217   next_pc = fetch_instruction (pc, &it, &instr);
1218
1219   /* We want to check if we have a recognizable function start before we
1220      look ahead for a prologue.  */
1221   if (pc < lim_pc && next_pc
1222       && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL))
1223     {
1224       /* alloc - start of a regular function.  */
1225       int sor = (int) ((instr & 0x00078000000LL) >> 27);
1226       int sol = (int) ((instr & 0x00007f00000LL) >> 20);
1227       int sof = (int) ((instr & 0x000000fe000LL) >> 13);
1228       int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
1229
1230       /* Verify that the current cfm matches what we think is the
1231          function start.  If we have somehow jumped within a function,
1232          we do not want to interpret the prologue and calculate the
1233          addresses of various registers such as the return address.
1234          We will instead treat the frame as frameless. */
1235       if (!this_frame ||
1236           (sof == (cache->cfm & 0x7f) &&
1237            sol == ((cache->cfm >> 7) & 0x7f)))
1238         frameless = 0;
1239
1240       cfm_reg = rN;
1241       last_prologue_pc = next_pc;
1242       pc = next_pc;
1243     }
1244   else
1245     {
1246       /* Look for a leaf routine.  */
1247       if (pc < lim_pc && next_pc
1248           && (it == I || it == M)
1249           && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
1250         {
1251           /* adds rN = imm14, rM   (or mov rN, rM  when imm14 is 0) */
1252           int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
1253                            | ((instr & 0x001f8000000LL) >> 20)
1254                            | ((instr & 0x000000fe000LL) >> 13));
1255           int rM = (int) ((instr & 0x00007f00000LL) >> 20);
1256           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
1257           int qp = (int) (instr & 0x0000000003fLL);
1258           if (qp == 0 && rN == 2 && imm == 0 && rM == 12 && fp_reg == 0)
1259             {
1260               /* mov r2, r12 - beginning of leaf routine */
1261               fp_reg = rN;
1262               last_prologue_pc = next_pc;
1263             }
1264         }
1265
1266       /* If we don't recognize a regular function or leaf routine, we are
1267          done.  */
1268       if (!fp_reg)
1269         {
1270           pc = lim_pc;
1271           if (trust_limit)
1272             last_prologue_pc = lim_pc;
1273         }
1274     }
1275
1276   /* Loop, looking for prologue instructions, keeping track of
1277      where preserved registers were spilled. */
1278   while (pc < lim_pc)
1279     {
1280       next_pc = fetch_instruction (pc, &it, &instr);
1281       if (next_pc == 0)
1282         break;
1283
1284       if (it == B && ((instr & 0x1e1f800003fLL) != 0x04000000000LL))
1285         {
1286           /* Exit loop upon hitting a non-nop branch instruction. */
1287           if (trust_limit)
1288             lim_pc = pc;
1289           break;
1290         }
1291       else if (((instr & 0x3fLL) != 0LL) &&
1292                (frameless || ret_reg != 0))
1293         {
1294           /* Exit loop upon hitting a predicated instruction if
1295              we already have the return register or if we are frameless.  */
1296           if (trust_limit)
1297             lim_pc = pc;
1298           break;
1299         }
1300       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00188000000LL))
1301         {
1302           /* Move from BR */
1303           int b2 = (int) ((instr & 0x0000000e000LL) >> 13);
1304           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
1305           int qp = (int) (instr & 0x0000000003f);
1306
1307           if (qp == 0 && b2 == 0 && rN >= 32 && ret_reg == 0)
1308             {
1309               ret_reg = rN;
1310               last_prologue_pc = next_pc;
1311             }
1312         }
1313       else if ((it == I || it == M)
1314           && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
1315         {
1316           /* adds rN = imm14, rM   (or mov rN, rM  when imm14 is 0) */
1317           int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
1318                            | ((instr & 0x001f8000000LL) >> 20)
1319                            | ((instr & 0x000000fe000LL) >> 13));
1320           int rM = (int) ((instr & 0x00007f00000LL) >> 20);
1321           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
1322           int qp = (int) (instr & 0x0000000003fLL);
1323
1324           if (qp == 0 && rN >= 32 && imm == 0 && rM == 12 && fp_reg == 0)
1325             {
1326               /* mov rN, r12 */
1327               fp_reg = rN;
1328               last_prologue_pc = next_pc;
1329             }
1330           else if (qp == 0 && rN == 12 && rM == 12)
1331             {
1332               /* adds r12, -mem_stack_frame_size, r12 */
1333               mem_stack_frame_size -= imm;
1334               last_prologue_pc = next_pc;
1335             }
1336           else if (qp == 0 && rN == 2
1337                 && ((rM == fp_reg && fp_reg != 0) || rM == 12))
1338             {
1339               char buf[MAX_REGISTER_SIZE];
1340               CORE_ADDR saved_sp = 0;
1341               /* adds r2, spilloffset, rFramePointer
1342                    or
1343                  adds r2, spilloffset, r12
1344
1345                  Get ready for stf.spill or st8.spill instructions.
1346                  The address to start spilling at is loaded into r2.
1347                  FIXME:  Why r2?  That's what gcc currently uses; it
1348                  could well be different for other compilers.  */
1349
1350               /* Hmm... whether or not this will work will depend on
1351                  where the pc is.  If it's still early in the prologue
1352                  this'll be wrong.  FIXME */
1353               if (this_frame)
1354                 {
1355                   get_frame_register (this_frame, sp_regnum, buf);
1356                   saved_sp = extract_unsigned_integer (buf, 8);
1357                 }
1358               spill_addr  = saved_sp
1359                           + (rM == 12 ? 0 : mem_stack_frame_size)
1360                           + imm;
1361               spill_reg   = rN;
1362               last_prologue_pc = next_pc;
1363             }
1364           else if (qp == 0 && rM >= 32 && rM < 40 && !instores[rM-32] &&
1365                    rN < 256 && imm == 0)
1366             {
1367               /* mov rN, rM where rM is an input register */
1368               reg_contents[rN] = rM;
1369               last_prologue_pc = next_pc;
1370             }
1371           else if (frameless && qp == 0 && rN == fp_reg && imm == 0 &&
1372                    rM == 2)
1373             {
1374               /* mov r12, r2 */
1375               last_prologue_pc = next_pc;
1376               break;
1377             }
1378         }
1379       else if (it == M
1380             && (   ((instr & 0x1efc0000000LL) == 0x0eec0000000LL)
1381                 || ((instr & 0x1ffc8000000LL) == 0x0cec0000000LL) ))
1382         {
1383           /* stf.spill [rN] = fM, imm9
1384              or
1385              stf.spill [rN] = fM  */
1386
1387           int imm = imm9(instr);
1388           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1389           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
1390           int qp = (int) (instr & 0x0000000003fLL);
1391           if (qp == 0 && rN == spill_reg && spill_addr != 0
1392               && ((2 <= fM && fM <= 5) || (16 <= fM && fM <= 31)))
1393             {
1394               cache->saved_regs[IA64_FR0_REGNUM + fM] = spill_addr;
1395
1396               if ((instr & 0x1efc0000000LL) == 0x0eec0000000LL)
1397                 spill_addr += imm;
1398               else
1399                 spill_addr = 0;         /* last one; must be done */
1400               last_prologue_pc = next_pc;
1401             }
1402         }
1403       else if ((it == M && ((instr & 0x1eff8000000LL) == 0x02110000000LL))
1404             || (it == I && ((instr & 0x1eff8000000LL) == 0x00050000000LL)) )
1405         {
1406           /* mov.m rN = arM
1407                or
1408              mov.i rN = arM */
1409
1410           int arM = (int) ((instr & 0x00007f00000LL) >> 20);
1411           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
1412           int qp  = (int) (instr & 0x0000000003fLL);
1413           if (qp == 0 && isScratch (rN) && arM == 36 /* ar.unat */)
1414             {
1415               /* We have something like "mov.m r3 = ar.unat".  Remember the
1416                  r3 (or whatever) and watch for a store of this register... */
1417               unat_save_reg = rN;
1418               last_prologue_pc = next_pc;
1419             }
1420         }
1421       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00198000000LL))
1422         {
1423           /* mov rN = pr */
1424           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
1425           int qp  = (int) (instr & 0x0000000003fLL);
1426           if (qp == 0 && isScratch (rN))
1427             {
1428               pr_save_reg = rN;
1429               last_prologue_pc = next_pc;
1430             }
1431         }
1432       else if (it == M
1433             && (   ((instr & 0x1ffc8000000LL) == 0x08cc0000000LL)
1434                 || ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)))
1435         {
1436           /* st8 [rN] = rM
1437               or
1438              st8 [rN] = rM, imm9 */
1439           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1440           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1441           int qp = (int) (instr & 0x0000000003fLL);
1442           int indirect = rM < 256 ? reg_contents[rM] : 0;
1443           if (qp == 0 && rN == spill_reg && spill_addr != 0
1444               && (rM == unat_save_reg || rM == pr_save_reg))
1445             {
1446               /* We've found a spill of either the UNAT register or the PR
1447                  register.  (Well, not exactly; what we've actually found is
1448                  a spill of the register that UNAT or PR was moved to).
1449                  Record that fact and move on... */
1450               if (rM == unat_save_reg)
1451                 {
1452                   /* Track UNAT register */
1453                   cache->saved_regs[IA64_UNAT_REGNUM] = spill_addr;
1454                   unat_save_reg = 0;
1455                 }
1456               else
1457                 {
1458                   /* Track PR register */
1459                   cache->saved_regs[IA64_PR_REGNUM] = spill_addr;
1460                   pr_save_reg = 0;
1461                 }
1462               if ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)
1463                 /* st8 [rN] = rM, imm9 */
1464                 spill_addr += imm9(instr);
1465               else
1466                 spill_addr = 0;         /* must be done spilling */
1467               last_prologue_pc = next_pc;
1468             }
1469           else if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1470             {
1471               /* Allow up to one store of each input register. */
1472               instores[rM-32] = 1;
1473               last_prologue_pc = next_pc;
1474             }
1475           else if (qp == 0 && 32 <= indirect && indirect < 40 &&
1476                    !instores[indirect-32])
1477             {
1478               /* Allow an indirect store of an input register.  */
1479               instores[indirect-32] = 1;
1480               last_prologue_pc = next_pc;
1481             }
1482         }
1483       else if (it == M && ((instr & 0x1ff08000000LL) == 0x08c00000000LL))
1484         {
1485           /* One of
1486                st1 [rN] = rM
1487                st2 [rN] = rM
1488                st4 [rN] = rM
1489                st8 [rN] = rM
1490              Note that the st8 case is handled in the clause above.
1491
1492              Advance over stores of input registers. One store per input
1493              register is permitted. */
1494           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1495           int qp = (int) (instr & 0x0000000003fLL);
1496           int indirect = rM < 256 ? reg_contents[rM] : 0;
1497           if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1498             {
1499               instores[rM-32] = 1;
1500               last_prologue_pc = next_pc;
1501             }
1502           else if (qp == 0 && 32 <= indirect && indirect < 40 &&
1503                    !instores[indirect-32])
1504             {
1505               /* Allow an indirect store of an input register.  */
1506               instores[indirect-32] = 1;
1507               last_prologue_pc = next_pc;
1508             }
1509         }
1510       else if (it == M && ((instr & 0x1ff88000000LL) == 0x0cc80000000LL))
1511         {
1512           /* Either
1513                stfs [rN] = fM
1514              or
1515                stfd [rN] = fM
1516
1517              Advance over stores of floating point input registers.  Again
1518              one store per register is permitted */
1519           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
1520           int qp = (int) (instr & 0x0000000003fLL);
1521           if (qp == 0 && 8 <= fM && fM < 16 && !infpstores[fM - 8])
1522             {
1523               infpstores[fM-8] = 1;
1524               last_prologue_pc = next_pc;
1525             }
1526         }
1527       else if (it == M
1528             && (   ((instr & 0x1ffc8000000LL) == 0x08ec0000000LL)
1529                 || ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)))
1530         {
1531           /* st8.spill [rN] = rM
1532                or
1533              st8.spill [rN] = rM, imm9 */
1534           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1535           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1536           int qp = (int) (instr & 0x0000000003fLL);
1537           if (qp == 0 && rN == spill_reg && 4 <= rM && rM <= 7)
1538             {
1539               /* We've found a spill of one of the preserved general purpose
1540                  regs.  Record the spill address and advance the spill
1541                  register if appropriate. */
1542               cache->saved_regs[IA64_GR0_REGNUM + rM] = spill_addr;
1543               if ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)
1544                 /* st8.spill [rN] = rM, imm9 */
1545                 spill_addr += imm9(instr);
1546               else
1547                 spill_addr = 0;         /* Done spilling */
1548               last_prologue_pc = next_pc;
1549             }
1550         }
1551
1552       pc = next_pc;
1553     }
1554
1555   /* If not frameless and we aren't called by skip_prologue, then we need
1556      to calculate registers for the previous frame which will be needed
1557      later.  */
1558
1559   if (!frameless && this_frame)
1560     {
1561       /* Extract the size of the rotating portion of the stack
1562          frame and the register rename base from the current
1563          frame marker. */
1564       cfm = cache->cfm;
1565       sor = cache->sor;
1566       sof = cache->sof;
1567       sol = cache->sol;
1568       rrb_gr = (cfm >> 18) & 0x7f;
1569
1570       /* Find the bof (beginning of frame).  */
1571       bof = rse_address_add (cache->bsp, -sof);
1572
1573       for (i = 0, addr = bof;
1574            i < sof;
1575            i++, addr += 8)
1576         {
1577           if (IS_NaT_COLLECTION_ADDR (addr))
1578             {
1579               addr += 8;
1580             }
1581           if (i+32 == cfm_reg)
1582             cache->saved_regs[IA64_CFM_REGNUM] = addr;
1583           if (i+32 == ret_reg)
1584             cache->saved_regs[IA64_VRAP_REGNUM] = addr;
1585           if (i+32 == fp_reg)
1586             cache->saved_regs[IA64_VFP_REGNUM] = addr;
1587         }
1588
1589       /* For the previous argument registers we require the previous bof.
1590          If we can't find the previous cfm, then we can do nothing.  */
1591       cfm = 0;
1592       if (cache->saved_regs[IA64_CFM_REGNUM] != 0)
1593         {
1594           cfm = read_memory_integer (cache->saved_regs[IA64_CFM_REGNUM], 8);
1595         }
1596       else if (cfm_reg != 0)
1597         {
1598           get_frame_register (this_frame, cfm_reg, buf);
1599           cfm = extract_unsigned_integer (buf, 8);
1600         }
1601       cache->prev_cfm = cfm;
1602
1603       if (cfm != 0)
1604         {
1605           sor = ((cfm >> 14) & 0xf) * 8;
1606           sof = (cfm & 0x7f);
1607           sol = (cfm >> 7) & 0x7f;
1608           rrb_gr = (cfm >> 18) & 0x7f;
1609
1610           /* The previous bof only requires subtraction of the sol (size of
1611              locals) due to the overlap between output and input of
1612              subsequent frames.  */
1613           bof = rse_address_add (bof, -sol);
1614
1615           for (i = 0, addr = bof;
1616                i < sof;
1617                i++, addr += 8)
1618             {
1619               if (IS_NaT_COLLECTION_ADDR (addr))
1620                 {
1621                   addr += 8;
1622                 }
1623               if (i < sor)
1624                 cache->saved_regs[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
1625                   = addr;
1626               else
1627                 cache->saved_regs[IA64_GR32_REGNUM + i] = addr;
1628             }
1629
1630         }
1631     }
1632
1633   /* Try and trust the lim_pc value whenever possible.  */
1634   if (trust_limit && lim_pc >= last_prologue_pc)
1635     last_prologue_pc = lim_pc;
1636
1637   cache->frameless = frameless;
1638   cache->after_prologue = last_prologue_pc;
1639   cache->mem_stack_frame_size = mem_stack_frame_size;
1640   cache->fp_reg = fp_reg;
1641
1642   return last_prologue_pc;
1643 }
1644
1645 CORE_ADDR
1646 ia64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1647 {
1648   struct ia64_frame_cache cache;
1649   cache.base = 0;
1650   cache.after_prologue = 0;
1651   cache.cfm = 0;
1652   cache.bsp = 0;
1653
1654   /* Call examine_prologue with - as third argument since we don't have a next frame pointer to send.  */
1655   return examine_prologue (pc, pc+1024, 0, &cache);
1656 }
1657
1658
1659 /* Normal frames.  */
1660
1661 static struct ia64_frame_cache *
1662 ia64_frame_cache (struct frame_info *this_frame, void **this_cache)
1663 {
1664   struct ia64_frame_cache *cache;
1665   char buf[8];
1666   CORE_ADDR cfm, sof, sol, bsp, psr;
1667   int i;
1668
1669   if (*this_cache)
1670     return *this_cache;
1671
1672   cache = ia64_alloc_frame_cache ();
1673   *this_cache = cache;
1674
1675   get_frame_register (this_frame, sp_regnum, buf);
1676   cache->saved_sp = extract_unsigned_integer (buf, 8);
1677
1678   /* We always want the bsp to point to the end of frame.
1679      This way, we can always get the beginning of frame (bof)
1680      by subtracting frame size.  */
1681   get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
1682   cache->bsp = extract_unsigned_integer (buf, 8);
1683
1684   get_frame_register (this_frame, IA64_PSR_REGNUM, buf);
1685   psr = extract_unsigned_integer (buf, 8);
1686
1687   get_frame_register (this_frame, IA64_CFM_REGNUM, buf);
1688   cfm = extract_unsigned_integer (buf, 8);
1689
1690   cache->sof = (cfm & 0x7f);
1691   cache->sol = (cfm >> 7) & 0x7f;
1692   cache->sor = ((cfm >> 14) & 0xf) * 8;
1693
1694   cache->cfm = cfm;
1695
1696   cache->pc = get_frame_func (this_frame);
1697
1698   if (cache->pc != 0)
1699     examine_prologue (cache->pc, get_frame_pc (this_frame), this_frame, cache);
1700
1701   cache->base = cache->saved_sp + cache->mem_stack_frame_size;
1702
1703   return cache;
1704 }
1705
1706 static void
1707 ia64_frame_this_id (struct frame_info *this_frame, void **this_cache,
1708                     struct frame_id *this_id)
1709 {
1710   struct ia64_frame_cache *cache =
1711     ia64_frame_cache (this_frame, this_cache);
1712
1713   /* If outermost frame, mark with null frame id.  */
1714   if (cache->base == 0)
1715     (*this_id) = null_frame_id;
1716   else
1717     (*this_id) = frame_id_build_special (cache->base, cache->pc, cache->bsp);
1718   if (gdbarch_debug >= 1)
1719     fprintf_unfiltered (gdb_stdlog,
1720                         "regular frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
1721                         paddr_nz (this_id->code_addr),
1722                         paddr_nz (this_id->stack_addr),
1723                         paddr_nz (cache->bsp),
1724                         host_address_to_string (this_frame));
1725 }
1726
1727 static struct value *
1728 ia64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1729                           int regnum)
1730 {
1731   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1732   struct ia64_frame_cache *cache = ia64_frame_cache (this_frame, this_cache);
1733   char buf[8];
1734
1735   gdb_assert (regnum >= 0);
1736
1737   if (!target_has_registers)
1738     error (_("No registers."));
1739
1740   if (regnum == gdbarch_sp_regnum (gdbarch))
1741     return frame_unwind_got_constant (this_frame, regnum, cache->base);
1742
1743   else if (regnum == IA64_BSP_REGNUM)
1744     {
1745       struct value *val;
1746       CORE_ADDR prev_cfm, bsp, prev_bsp;
1747
1748       /* We want to calculate the previous bsp as the end of the previous
1749          register stack frame.  This corresponds to what the hardware bsp
1750          register will be if we pop the frame back which is why we might
1751          have been called.  We know the beginning of the current frame is
1752          cache->bsp - cache->sof.  This value in the previous frame points
1753          to the start of the output registers.  We can calculate the end of
1754          that frame by adding the size of output:
1755             (sof (size of frame) - sol (size of locals)).  */
1756       val = ia64_frame_prev_register (this_frame, this_cache, IA64_CFM_REGNUM);
1757       prev_cfm = extract_unsigned_integer (value_contents_all (val), 8);
1758       bsp = rse_address_add (cache->bsp, -(cache->sof));
1759       prev_bsp =
1760         rse_address_add (bsp, (prev_cfm & 0x7f) - ((prev_cfm >> 7) & 0x7f));
1761
1762       return frame_unwind_got_constant (this_frame, regnum, prev_bsp);
1763     }
1764
1765   else if (regnum == IA64_CFM_REGNUM)
1766     {
1767       CORE_ADDR addr = cache->saved_regs[IA64_CFM_REGNUM];
1768
1769       if (addr != 0)
1770         return frame_unwind_got_memory (this_frame, regnum, addr);
1771
1772       if (cache->prev_cfm)
1773         return frame_unwind_got_constant (this_frame, regnum, cache->prev_cfm);
1774
1775       if (cache->frameless)
1776         return frame_unwind_got_register (this_frame, IA64_PFS_REGNUM,
1777                                           IA64_PFS_REGNUM);
1778       return frame_unwind_got_register (this_frame, regnum, 0);
1779     }
1780
1781   else if (regnum == IA64_VFP_REGNUM)
1782     {
1783       /* If the function in question uses an automatic register (r32-r127)
1784          for the frame pointer, it'll be found by ia64_find_saved_register()
1785          above.  If the function lacks one of these frame pointers, we can
1786          still provide a value since we know the size of the frame.  */
1787       return frame_unwind_got_constant (this_frame, regnum, cache->base);
1788     }
1789
1790   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
1791     {
1792       struct value *pr_val;
1793       ULONGEST prN;
1794
1795       pr_val = ia64_frame_prev_register (this_frame, this_cache,
1796                                          IA64_PR_REGNUM);
1797       if (VP16_REGNUM <= regnum && regnum <= VP63_REGNUM)
1798         {
1799           /* Fetch predicate register rename base from current frame
1800              marker for this frame.  */
1801           int rrb_pr = (cache->cfm >> 32) & 0x3f;
1802
1803           /* Adjust the register number to account for register rotation.  */
1804           regnum = VP16_REGNUM + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
1805         }
1806       prN = extract_bit_field (value_contents_all (pr_val),
1807                                regnum - VP0_REGNUM, 1);
1808       return frame_unwind_got_constant (this_frame, regnum, prN);
1809     }
1810
1811   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
1812     {
1813       struct value *unat_val;
1814       ULONGEST unatN;
1815       unat_val = ia64_frame_prev_register (this_frame, this_cache,
1816                                            IA64_UNAT_REGNUM);
1817       unatN = extract_bit_field (value_contents_all (unat_val),
1818                                  regnum - IA64_NAT0_REGNUM, 1);
1819       return frame_unwind_got_constant (this_frame, regnum, unatN);
1820     }
1821
1822   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
1823     {
1824       int natval = 0;
1825       /* Find address of general register corresponding to nat bit we're
1826          interested in.  */
1827       CORE_ADDR gr_addr;
1828
1829       gr_addr = cache->saved_regs[regnum - IA64_NAT0_REGNUM + IA64_GR0_REGNUM];
1830
1831       if (gr_addr != 0)
1832         {
1833           /* Compute address of nat collection bits.  */
1834           CORE_ADDR nat_addr = gr_addr | 0x1f8;
1835           CORE_ADDR bsp;
1836           CORE_ADDR nat_collection;
1837           int nat_bit;
1838
1839           /* If our nat collection address is bigger than bsp, we have to get
1840              the nat collection from rnat.  Otherwise, we fetch the nat
1841              collection from the computed address.  */
1842           get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
1843           bsp = extract_unsigned_integer (buf, 8);
1844           if (nat_addr >= bsp)
1845             {
1846               get_frame_register (this_frame, IA64_RNAT_REGNUM, buf);
1847               nat_collection = extract_unsigned_integer (buf, 8);
1848             }
1849           else
1850             nat_collection = read_memory_integer (nat_addr, 8);
1851           nat_bit = (gr_addr >> 3) & 0x3f;
1852           natval = (nat_collection >> nat_bit) & 1;
1853         }
1854
1855       return frame_unwind_got_constant (this_frame, regnum, natval);
1856     }
1857
1858   else if (regnum == IA64_IP_REGNUM)
1859     {
1860       CORE_ADDR pc = 0;
1861       CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
1862
1863       if (addr != 0)
1864         {
1865           read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM));
1866           pc = extract_unsigned_integer (buf, 8);
1867         }
1868       else if (cache->frameless)
1869         {
1870           get_frame_register (this_frame, IA64_BR0_REGNUM, buf);
1871           pc = extract_unsigned_integer (buf, 8);
1872         }
1873       pc &= ~0xf;
1874       return frame_unwind_got_constant (this_frame, regnum, pc);
1875     }
1876
1877   else if (regnum == IA64_PSR_REGNUM)
1878     {
1879       /* We don't know how to get the complete previous PSR, but we need it
1880          for the slot information when we unwind the pc (pc is formed of IP
1881          register plus slot information from PSR).  To get the previous
1882          slot information, we mask it off the return address.  */
1883       ULONGEST slot_num = 0;
1884       CORE_ADDR pc = 0;
1885       CORE_ADDR psr = 0;
1886       CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
1887
1888       get_frame_register (this_frame, IA64_PSR_REGNUM, buf);
1889       psr = extract_unsigned_integer (buf, 8);
1890
1891       if (addr != 0)
1892         {
1893           read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM));
1894           pc = extract_unsigned_integer (buf, 8);
1895         }
1896       else if (cache->frameless)
1897         {
1898           get_frame_register (this_frame, IA64_BR0_REGNUM, buf);
1899           pc = extract_unsigned_integer (buf, 8);
1900         }
1901       psr &= ~(3LL << 41);
1902       slot_num = pc & 0x3LL;
1903       psr |= (CORE_ADDR)slot_num << 41;
1904       return frame_unwind_got_constant (this_frame, regnum, psr);
1905     }
1906
1907   else if (regnum == IA64_BR0_REGNUM)
1908     {
1909       CORE_ADDR addr = cache->saved_regs[IA64_BR0_REGNUM];
1910
1911       if (addr != 0)
1912         return frame_unwind_got_memory (this_frame, regnum, addr);
1913
1914       return frame_unwind_got_constant (this_frame, regnum, 0);
1915     }
1916
1917   else if ((regnum >= IA64_GR32_REGNUM && regnum <= IA64_GR127_REGNUM)
1918            || (regnum >= V32_REGNUM && regnum <= V127_REGNUM))
1919     {
1920       CORE_ADDR addr = 0;
1921
1922       if (regnum >= V32_REGNUM)
1923         regnum = IA64_GR32_REGNUM + (regnum - V32_REGNUM);
1924       addr = cache->saved_regs[regnum];
1925       if (addr != 0)
1926         return frame_unwind_got_memory (this_frame, regnum, addr);
1927
1928       if (cache->frameless)
1929         {
1930           struct value *reg_val;
1931           CORE_ADDR prev_cfm, prev_bsp, prev_bof;
1932
1933           /* FIXME: brobecker/2008-05-01: Doesn't this seem redundant
1934              with the same code above?  */
1935           if (regnum >= V32_REGNUM)
1936             regnum = IA64_GR32_REGNUM + (regnum - V32_REGNUM);
1937           reg_val = ia64_frame_prev_register (this_frame, this_cache,
1938                                               IA64_CFM_REGNUM);
1939           prev_cfm = extract_unsigned_integer (value_contents_all (reg_val),
1940                                                8);
1941           reg_val = ia64_frame_prev_register (this_frame, this_cache,
1942                                               IA64_BSP_REGNUM);
1943           prev_bsp = extract_unsigned_integer (value_contents_all (reg_val),
1944                                                8);
1945           prev_bof = rse_address_add (prev_bsp, -(prev_cfm & 0x7f));
1946
1947           addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM));
1948           return frame_unwind_got_memory (this_frame, regnum, addr);
1949         }
1950
1951       return frame_unwind_got_constant (this_frame, regnum, 0);
1952     }
1953
1954   else /* All other registers.  */
1955     {
1956       CORE_ADDR addr = 0;
1957
1958       if (IA64_FR32_REGNUM <= regnum && regnum <= IA64_FR127_REGNUM)
1959         {
1960           /* Fetch floating point register rename base from current
1961              frame marker for this frame.  */
1962           int rrb_fr = (cache->cfm >> 25) & 0x7f;
1963
1964           /* Adjust the floating point register number to account for
1965              register rotation.  */
1966           regnum = IA64_FR32_REGNUM
1967                  + ((regnum - IA64_FR32_REGNUM) + rrb_fr) % 96;
1968         }
1969
1970       /* If we have stored a memory address, access the register.  */
1971       addr = cache->saved_regs[regnum];
1972       if (addr != 0)
1973         return frame_unwind_got_memory (this_frame, regnum, addr);
1974       /* Otherwise, punt and get the current value of the register.  */
1975       else
1976         return frame_unwind_got_register (this_frame, regnum, regnum);
1977     }
1978 }
1979
1980 static const struct frame_unwind ia64_frame_unwind =
1981 {
1982   NORMAL_FRAME,
1983   &ia64_frame_this_id,
1984   &ia64_frame_prev_register,
1985   NULL,
1986   default_frame_sniffer
1987 };
1988
1989 /* Signal trampolines.  */
1990
1991 static void
1992 ia64_sigtramp_frame_init_saved_regs (struct frame_info *this_frame,
1993                                      struct ia64_frame_cache *cache)
1994 {
1995   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
1996
1997   if (tdep->sigcontext_register_address)
1998     {
1999       int regno;
2000
2001       cache->saved_regs[IA64_VRAP_REGNUM] =
2002         tdep->sigcontext_register_address (cache->base, IA64_IP_REGNUM);
2003       cache->saved_regs[IA64_CFM_REGNUM] =
2004         tdep->sigcontext_register_address (cache->base, IA64_CFM_REGNUM);
2005       cache->saved_regs[IA64_PSR_REGNUM] =
2006         tdep->sigcontext_register_address (cache->base, IA64_PSR_REGNUM);
2007       cache->saved_regs[IA64_BSP_REGNUM] =
2008         tdep->sigcontext_register_address (cache->base, IA64_BSP_REGNUM);
2009       cache->saved_regs[IA64_RNAT_REGNUM] =
2010         tdep->sigcontext_register_address (cache->base, IA64_RNAT_REGNUM);
2011       cache->saved_regs[IA64_CCV_REGNUM] =
2012         tdep->sigcontext_register_address (cache->base, IA64_CCV_REGNUM);
2013       cache->saved_regs[IA64_UNAT_REGNUM] =
2014         tdep->sigcontext_register_address (cache->base, IA64_UNAT_REGNUM);
2015       cache->saved_regs[IA64_FPSR_REGNUM] =
2016         tdep->sigcontext_register_address (cache->base, IA64_FPSR_REGNUM);
2017       cache->saved_regs[IA64_PFS_REGNUM] =
2018         tdep->sigcontext_register_address (cache->base, IA64_PFS_REGNUM);
2019       cache->saved_regs[IA64_LC_REGNUM] =
2020         tdep->sigcontext_register_address (cache->base, IA64_LC_REGNUM);
2021       for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
2022         cache->saved_regs[regno] =
2023           tdep->sigcontext_register_address (cache->base, regno);
2024       for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
2025         cache->saved_regs[regno] =
2026           tdep->sigcontext_register_address (cache->base, regno);
2027       for (regno = IA64_FR2_REGNUM; regno <= IA64_FR31_REGNUM; regno++)
2028         cache->saved_regs[regno] =
2029           tdep->sigcontext_register_address (cache->base, regno);
2030     }
2031 }
2032
2033 static struct ia64_frame_cache *
2034 ia64_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
2035 {
2036   struct ia64_frame_cache *cache;
2037   CORE_ADDR addr;
2038   char buf[8];
2039   int i;
2040
2041   if (*this_cache)
2042     return *this_cache;
2043
2044   cache = ia64_alloc_frame_cache ();
2045
2046   get_frame_register (this_frame, sp_regnum, buf);
2047   /* Note that frame size is hard-coded below.  We cannot calculate it
2048      via prologue examination.  */
2049   cache->base = extract_unsigned_integer (buf, 8) + 16;
2050
2051   get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
2052   cache->bsp = extract_unsigned_integer (buf, 8);
2053
2054   get_frame_register (this_frame, IA64_CFM_REGNUM, buf);
2055   cache->cfm = extract_unsigned_integer (buf, 8);
2056   cache->sof = cache->cfm & 0x7f;
2057
2058   ia64_sigtramp_frame_init_saved_regs (this_frame, cache);
2059
2060   *this_cache = cache;
2061   return cache;
2062 }
2063
2064 static void
2065 ia64_sigtramp_frame_this_id (struct frame_info *this_frame,
2066                              void **this_cache, struct frame_id *this_id)
2067 {
2068   struct ia64_frame_cache *cache =
2069     ia64_sigtramp_frame_cache (this_frame, this_cache);
2070
2071   (*this_id) = frame_id_build_special (cache->base,
2072                                        get_frame_pc (this_frame),
2073                                        cache->bsp);
2074   if (gdbarch_debug >= 1)
2075     fprintf_unfiltered (gdb_stdlog,
2076                         "sigtramp frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
2077                         paddr_nz (this_id->code_addr),
2078                         paddr_nz (this_id->stack_addr),
2079                         paddr_nz (cache->bsp),
2080                         host_address_to_string (this_frame));
2081 }
2082
2083 static struct value *
2084 ia64_sigtramp_frame_prev_register (struct frame_info *this_frame,
2085                                    void **this_cache, int regnum)
2086 {
2087   char buf[MAX_REGISTER_SIZE];
2088
2089   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2090   struct ia64_frame_cache *cache =
2091     ia64_sigtramp_frame_cache (this_frame, this_cache);
2092
2093   gdb_assert (regnum >= 0);
2094
2095   if (!target_has_registers)
2096     error (_("No registers."));
2097
2098   if (regnum == IA64_IP_REGNUM)
2099     {
2100       CORE_ADDR pc = 0;
2101       CORE_ADDR addr = cache->saved_regs[IA64_VRAP_REGNUM];
2102
2103       if (addr != 0)
2104         {
2105           read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM));
2106           pc = extract_unsigned_integer (buf, 8);
2107         }
2108       pc &= ~0xf;
2109       return frame_unwind_got_constant (this_frame, regnum, pc);
2110     }
2111
2112   else if ((regnum >= IA64_GR32_REGNUM && regnum <= IA64_GR127_REGNUM)
2113            || (regnum >= V32_REGNUM && regnum <= V127_REGNUM))
2114     {
2115       CORE_ADDR addr = 0;
2116
2117       if (regnum >= V32_REGNUM)
2118         regnum = IA64_GR32_REGNUM + (regnum - V32_REGNUM);
2119       addr = cache->saved_regs[regnum];
2120       if (addr != 0)
2121         return frame_unwind_got_memory (this_frame, regnum, addr);
2122
2123       return frame_unwind_got_constant (this_frame, regnum, 0);
2124     }
2125
2126   else  /* All other registers not listed above.  */
2127     {
2128       CORE_ADDR addr = cache->saved_regs[regnum];
2129
2130       if (addr != 0)
2131         return frame_unwind_got_memory (this_frame, regnum, addr);
2132
2133       return frame_unwind_got_constant (this_frame, regnum, 0);
2134     }
2135 }
2136
2137 static int
2138 ia64_sigtramp_frame_sniffer (const struct frame_unwind *self,
2139                              struct frame_info *this_frame,
2140                              void **this_cache)
2141 {
2142   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
2143   if (tdep->pc_in_sigtramp)
2144     {
2145       CORE_ADDR pc = get_frame_pc (this_frame);
2146
2147       if (tdep->pc_in_sigtramp (pc))
2148         return 1;
2149     }
2150
2151   return 0;
2152 }
2153
2154 static const struct frame_unwind ia64_sigtramp_frame_unwind =
2155 {
2156   SIGTRAMP_FRAME,
2157   ia64_sigtramp_frame_this_id,
2158   ia64_sigtramp_frame_prev_register,
2159   NULL,
2160   ia64_sigtramp_frame_sniffer
2161 };
2162
2163 \f
2164
2165 static CORE_ADDR
2166 ia64_frame_base_address (struct frame_info *this_frame, void **this_cache)
2167 {
2168   struct ia64_frame_cache *cache = ia64_frame_cache (this_frame, this_cache);
2169
2170   return cache->base;
2171 }
2172
2173 static const struct frame_base ia64_frame_base =
2174 {
2175   &ia64_frame_unwind,
2176   ia64_frame_base_address,
2177   ia64_frame_base_address,
2178   ia64_frame_base_address
2179 };
2180
2181 #ifdef HAVE_LIBUNWIND_IA64_H
2182
2183 struct ia64_unwind_table_entry
2184   {
2185     unw_word_t start_offset;
2186     unw_word_t end_offset;
2187     unw_word_t info_offset;
2188   };
2189
2190 static __inline__ uint64_t
2191 ia64_rse_slot_num (uint64_t addr)
2192 {
2193   return (addr >> 3) & 0x3f;
2194 }
2195
2196 /* Skip over a designated number of registers in the backing
2197    store, remembering every 64th position is for NAT.  */
2198 static __inline__ uint64_t
2199 ia64_rse_skip_regs (uint64_t addr, long num_regs)
2200 {
2201   long delta = ia64_rse_slot_num(addr) + num_regs;
2202
2203   if (num_regs < 0)
2204     delta -= 0x3e;
2205   return addr + ((num_regs + delta/0x3f) << 3);
2206 }
2207
2208 /* Gdb libunwind-frame callback function to convert from an ia64 gdb register
2209    number to a libunwind register number.  */
2210 static int
2211 ia64_gdb2uw_regnum (int regnum)
2212 {
2213   if (regnum == sp_regnum)
2214     return UNW_IA64_SP;
2215   else if (regnum == IA64_BSP_REGNUM)
2216     return UNW_IA64_BSP;
2217   else if ((unsigned) (regnum - IA64_GR0_REGNUM) < 128)
2218     return UNW_IA64_GR + (regnum - IA64_GR0_REGNUM);
2219   else if ((unsigned) (regnum - V32_REGNUM) < 95)
2220     return UNW_IA64_GR + 32 + (regnum - V32_REGNUM);
2221   else if ((unsigned) (regnum - IA64_FR0_REGNUM) < 128)
2222     return UNW_IA64_FR + (regnum - IA64_FR0_REGNUM);
2223   else if ((unsigned) (regnum - IA64_PR0_REGNUM) < 64)
2224     return -1;
2225   else if ((unsigned) (regnum - IA64_BR0_REGNUM) < 8)
2226     return UNW_IA64_BR + (regnum - IA64_BR0_REGNUM);
2227   else if (regnum == IA64_PR_REGNUM)
2228     return UNW_IA64_PR;
2229   else if (regnum == IA64_IP_REGNUM)
2230     return UNW_REG_IP;
2231   else if (regnum == IA64_CFM_REGNUM)
2232     return UNW_IA64_CFM;
2233   else if ((unsigned) (regnum - IA64_AR0_REGNUM) < 128)
2234     return UNW_IA64_AR + (regnum - IA64_AR0_REGNUM);
2235   else if ((unsigned) (regnum - IA64_NAT0_REGNUM) < 128)
2236     return UNW_IA64_NAT + (regnum - IA64_NAT0_REGNUM);
2237   else
2238     return -1;
2239 }
2240
2241 /* Gdb libunwind-frame callback function to convert from a libunwind register
2242    number to a ia64 gdb register number.  */
2243 static int
2244 ia64_uw2gdb_regnum (int uw_regnum)
2245 {
2246   if (uw_regnum == UNW_IA64_SP)
2247     return sp_regnum;
2248   else if (uw_regnum == UNW_IA64_BSP)
2249     return IA64_BSP_REGNUM;
2250   else if ((unsigned) (uw_regnum - UNW_IA64_GR) < 32)
2251     return IA64_GR0_REGNUM + (uw_regnum - UNW_IA64_GR);
2252   else if ((unsigned) (uw_regnum - UNW_IA64_GR) < 128)
2253     return V32_REGNUM + (uw_regnum - (IA64_GR0_REGNUM + 32));
2254   else if ((unsigned) (uw_regnum - UNW_IA64_FR) < 128)
2255     return IA64_FR0_REGNUM + (uw_regnum - UNW_IA64_FR);
2256   else if ((unsigned) (uw_regnum - UNW_IA64_BR) < 8)
2257     return IA64_BR0_REGNUM + (uw_regnum - UNW_IA64_BR);
2258   else if (uw_regnum == UNW_IA64_PR)
2259     return IA64_PR_REGNUM;
2260   else if (uw_regnum == UNW_REG_IP)
2261     return IA64_IP_REGNUM;
2262   else if (uw_regnum == UNW_IA64_CFM)
2263     return IA64_CFM_REGNUM;
2264   else if ((unsigned) (uw_regnum - UNW_IA64_AR) < 128)
2265     return IA64_AR0_REGNUM + (uw_regnum - UNW_IA64_AR);
2266   else if ((unsigned) (uw_regnum - UNW_IA64_NAT) < 128)
2267     return IA64_NAT0_REGNUM + (uw_regnum - UNW_IA64_NAT);
2268   else
2269     return -1;
2270 }
2271
2272 /* Gdb libunwind-frame callback function to reveal if register is a float
2273    register or not.  */
2274 static int
2275 ia64_is_fpreg (int uw_regnum)
2276 {
2277   return unw_is_fpreg (uw_regnum);
2278 }
2279
2280 /* Libunwind callback accessor function for general registers.  */
2281 static int
2282 ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val,
2283                  int write, void *arg)
2284 {
2285   int regnum = ia64_uw2gdb_regnum (uw_regnum);
2286   unw_word_t bsp, sof, sol, cfm, psr, ip;
2287   struct frame_info *this_frame = arg;
2288   long new_sof, old_sof;
2289   char buf[MAX_REGISTER_SIZE];
2290
2291   /* We never call any libunwind routines that need to write registers.  */
2292   gdb_assert (!write);
2293
2294   switch (uw_regnum)
2295     {
2296       case UNW_REG_IP:
2297         /* Libunwind expects to see the pc value which means the slot number
2298            from the psr must be merged with the ip word address.  */
2299         get_frame_register (this_frame, IA64_IP_REGNUM, buf);
2300         ip = extract_unsigned_integer (buf, 8);
2301         get_frame_register (this_frame, IA64_PSR_REGNUM, buf);
2302         psr = extract_unsigned_integer (buf, 8);
2303         *val = ip | ((psr >> 41) & 0x3);
2304         break;
2305
2306       case UNW_IA64_AR_BSP:
2307         /* Libunwind expects to see the beginning of the current register
2308            frame so we must account for the fact that ptrace() will return a value
2309            for bsp that points *after* the current register frame.  */
2310         get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
2311         bsp = extract_unsigned_integer (buf, 8);
2312         get_frame_register (this_frame, IA64_CFM_REGNUM, buf);
2313         cfm = extract_unsigned_integer (buf, 8);
2314         sof = (cfm & 0x7f);
2315         *val = ia64_rse_skip_regs (bsp, -sof);
2316         break;
2317
2318       case UNW_IA64_AR_BSPSTORE:
2319         /* Libunwind wants bspstore to be after the current register frame.
2320            This is what ptrace() and gdb treats as the regular bsp value.  */
2321         get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
2322         *val = extract_unsigned_integer (buf, 8);
2323         break;
2324
2325       default:
2326         /* For all other registers, just unwind the value directly.  */
2327         get_frame_register (this_frame, regnum, buf);
2328         *val = extract_unsigned_integer (buf, 8);
2329         break;
2330     }
2331
2332   if (gdbarch_debug >= 1)
2333     fprintf_unfiltered (gdb_stdlog,
2334                         "  access_reg: from cache: %4s=0x%s\n",
2335                         (((unsigned) regnum <= IA64_NAT127_REGNUM)
2336                         ? ia64_register_names[regnum] : "r??"),
2337                         paddr_nz (*val));
2338   return 0;
2339 }
2340
2341 /* Libunwind callback accessor function for floating-point registers.  */
2342 static int
2343 ia64_access_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_fpreg_t *val,
2344                    int write, void *arg)
2345 {
2346   int regnum = ia64_uw2gdb_regnum (uw_regnum);
2347   struct frame_info *this_frame = arg;
2348
2349   /* We never call any libunwind routines that need to write registers.  */
2350   gdb_assert (!write);
2351
2352   get_frame_register (this_frame, regnum, (char *) val);
2353
2354   return 0;
2355 }
2356
2357 /* Libunwind callback accessor function for top-level rse registers.  */
2358 static int
2359 ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val,
2360                      int write, void *arg)
2361 {
2362   int regnum = ia64_uw2gdb_regnum (uw_regnum);
2363   unw_word_t bsp, sof, sol, cfm, psr, ip;
2364   struct regcache *regcache = arg;
2365   long new_sof, old_sof;
2366   char buf[MAX_REGISTER_SIZE];
2367
2368   /* We never call any libunwind routines that need to write registers.  */
2369   gdb_assert (!write);
2370
2371   switch (uw_regnum)
2372     {
2373       case UNW_REG_IP:
2374         /* Libunwind expects to see the pc value which means the slot number
2375            from the psr must be merged with the ip word address.  */
2376         regcache_cooked_read (regcache, IA64_IP_REGNUM, buf);
2377         ip = extract_unsigned_integer (buf, 8);
2378         regcache_cooked_read (regcache, IA64_PSR_REGNUM, buf);
2379         psr = extract_unsigned_integer (buf, 8);
2380         *val = ip | ((psr >> 41) & 0x3);
2381         break;
2382
2383       case UNW_IA64_AR_BSP:
2384         /* Libunwind expects to see the beginning of the current register
2385            frame so we must account for the fact that ptrace() will return a value
2386            for bsp that points *after* the current register frame.  */
2387         regcache_cooked_read (regcache, IA64_BSP_REGNUM, buf);
2388         bsp = extract_unsigned_integer (buf, 8);
2389         regcache_cooked_read (regcache, IA64_CFM_REGNUM, buf);
2390         cfm = extract_unsigned_integer (buf, 8);
2391         sof = (cfm & 0x7f);
2392         *val = ia64_rse_skip_regs (bsp, -sof);
2393         break;
2394
2395       case UNW_IA64_AR_BSPSTORE:
2396         /* Libunwind wants bspstore to be after the current register frame.
2397            This is what ptrace() and gdb treats as the regular bsp value.  */
2398         regcache_cooked_read (regcache, IA64_BSP_REGNUM, buf);
2399         *val = extract_unsigned_integer (buf, 8);
2400         break;
2401
2402       default:
2403         /* For all other registers, just unwind the value directly.  */
2404         regcache_cooked_read (regcache, regnum, buf);
2405         *val = extract_unsigned_integer (buf, 8);
2406         break;
2407     }
2408
2409   if (gdbarch_debug >= 1)
2410     fprintf_unfiltered (gdb_stdlog,
2411                         "  access_rse_reg: from cache: %4s=0x%s\n",
2412                         (((unsigned) regnum <= IA64_NAT127_REGNUM)
2413                          ? ia64_register_names[regnum] : "r??"),
2414                         paddr_nz (*val));
2415
2416   return 0;
2417 }
2418
2419 /* Libunwind callback accessor function for top-level fp registers.  */
2420 static int
2421 ia64_access_rse_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum,
2422                        unw_fpreg_t *val, int write, void *arg)
2423 {
2424   int regnum = ia64_uw2gdb_regnum (uw_regnum);
2425   struct regcache *regcache = arg;
2426
2427   /* We never call any libunwind routines that need to write registers.  */
2428   gdb_assert (!write);
2429
2430   regcache_cooked_read (regcache, regnum, (char *) val);
2431
2432   return 0;
2433 }
2434
2435 /* Libunwind callback accessor function for accessing memory.  */
2436 static int
2437 ia64_access_mem (unw_addr_space_t as,
2438                  unw_word_t addr, unw_word_t *val,
2439                  int write, void *arg)
2440 {
2441   if (addr - KERNEL_START < ktab_size)
2442     {
2443       unw_word_t *laddr = (unw_word_t*) ((char *) ktab
2444                           + (addr - KERNEL_START));
2445
2446       if (write)
2447         *laddr = *val;
2448       else
2449         *val = *laddr;
2450       return 0;
2451     }
2452
2453   /* XXX do we need to normalize byte-order here?  */
2454   if (write)
2455     return target_write_memory (addr, (char *) val, sizeof (unw_word_t));
2456   else
2457     return target_read_memory (addr, (char *) val, sizeof (unw_word_t));
2458 }
2459
2460 /* Call low-level function to access the kernel unwind table.  */
2461 static LONGEST
2462 getunwind_table (gdb_byte **buf_p)
2463 {
2464   LONGEST x;
2465
2466   /* FIXME drow/2005-09-10: This code used to call
2467      ia64_linux_xfer_unwind_table directly to fetch the unwind table
2468      for the currently running ia64-linux kernel.  That data should
2469      come from the core file and be accessed via the auxv vector; if
2470      we want to preserve fall back to the running kernel's table, then
2471      we should find a way to override the corefile layer's
2472      xfer_partial method.  */
2473
2474   x = target_read_alloc (&current_target, TARGET_OBJECT_UNWIND_TABLE,
2475                          NULL, buf_p);
2476
2477   return x;
2478 }
2479
2480 /* Get the kernel unwind table.  */
2481 static int
2482 get_kernel_table (unw_word_t ip, unw_dyn_info_t *di)
2483 {
2484   static struct ia64_table_entry *etab;
2485
2486   if (!ktab)
2487     {
2488       gdb_byte *ktab_buf;
2489       LONGEST size;
2490
2491       size = getunwind_table (&ktab_buf);
2492       if (size <= 0)
2493         return -UNW_ENOINFO;
2494
2495       ktab = (struct ia64_table_entry *) ktab_buf;
2496       ktab_size = size;
2497
2498       for (etab = ktab; etab->start_offset; ++etab)
2499         etab->info_offset += KERNEL_START;
2500     }
2501
2502   if (ip < ktab[0].start_offset || ip >= etab[-1].end_offset)
2503     return -UNW_ENOINFO;
2504
2505   di->format = UNW_INFO_FORMAT_TABLE;
2506   di->gp = 0;
2507   di->start_ip = ktab[0].start_offset;
2508   di->end_ip = etab[-1].end_offset;
2509   di->u.ti.name_ptr = (unw_word_t) "<kernel>";
2510   di->u.ti.segbase = 0;
2511   di->u.ti.table_len = ((char *) etab - (char *) ktab) / sizeof (unw_word_t);
2512   di->u.ti.table_data = (unw_word_t *) ktab;
2513
2514   if (gdbarch_debug >= 1)
2515     fprintf_unfiltered (gdb_stdlog, "get_kernel_table: found table `%s': "
2516                         "segbase=0x%s, length=%s, gp=0x%s\n",
2517                         (char *) di->u.ti.name_ptr,
2518                         paddr_nz (di->u.ti.segbase),
2519                         pulongest (di->u.ti.table_len),
2520                         paddr_nz (di->gp));
2521   return 0;
2522 }
2523
2524 /* Find the unwind table entry for a specified address.  */
2525 static int
2526 ia64_find_unwind_table (struct objfile *objfile, unw_word_t ip,
2527                         unw_dyn_info_t *dip, void **buf)
2528 {
2529   Elf_Internal_Phdr *phdr, *p_text = NULL, *p_unwind = NULL;
2530   Elf_Internal_Ehdr *ehdr;
2531   unw_word_t segbase = 0;
2532   CORE_ADDR load_base;
2533   bfd *bfd;
2534   int i;
2535
2536   bfd = objfile->obfd;
2537
2538   ehdr = elf_tdata (bfd)->elf_header;
2539   phdr = elf_tdata (bfd)->phdr;
2540
2541   load_base = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2542
2543   for (i = 0; i < ehdr->e_phnum; ++i)
2544     {
2545       switch (phdr[i].p_type)
2546         {
2547         case PT_LOAD:
2548           if ((unw_word_t) (ip - load_base - phdr[i].p_vaddr)
2549               < phdr[i].p_memsz)
2550             p_text = phdr + i;
2551           break;
2552
2553         case PT_IA_64_UNWIND:
2554           p_unwind = phdr + i;
2555           break;
2556
2557         default:
2558           break;
2559         }
2560     }
2561
2562   if (!p_text || !p_unwind)
2563     return -UNW_ENOINFO;
2564
2565   /* Verify that the segment that contains the IP also contains
2566      the static unwind table.  If not, we may be in the Linux kernel's
2567      DSO gate page in which case the unwind table is another segment.
2568      Otherwise, we are dealing with runtime-generated code, for which we
2569      have no info here.  */
2570   segbase = p_text->p_vaddr + load_base;
2571
2572   if ((p_unwind->p_vaddr - p_text->p_vaddr) >= p_text->p_memsz)
2573     {
2574       int ok = 0;
2575       for (i = 0; i < ehdr->e_phnum; ++i)
2576         {
2577           if (phdr[i].p_type == PT_LOAD
2578               && (p_unwind->p_vaddr - phdr[i].p_vaddr) < phdr[i].p_memsz)
2579             {
2580               ok = 1;
2581               /* Get the segbase from the section containing the
2582                  libunwind table.  */
2583               segbase = phdr[i].p_vaddr + load_base;
2584             }
2585         }
2586       if (!ok)
2587         return -UNW_ENOINFO;
2588     }
2589
2590   dip->start_ip = p_text->p_vaddr + load_base;
2591   dip->end_ip = dip->start_ip + p_text->p_memsz;
2592   dip->gp = ia64_find_global_pointer (ip);
2593   dip->format = UNW_INFO_FORMAT_REMOTE_TABLE;
2594   dip->u.rti.name_ptr = (unw_word_t) bfd_get_filename (bfd);
2595   dip->u.rti.segbase = segbase;
2596   dip->u.rti.table_len = p_unwind->p_memsz / sizeof (unw_word_t);
2597   dip->u.rti.table_data = p_unwind->p_vaddr + load_base;
2598
2599   return 0;
2600 }
2601
2602 /* Libunwind callback accessor function to acquire procedure unwind-info.  */
2603 static int
2604 ia64_find_proc_info_x (unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
2605                        int need_unwind_info, void *arg)
2606 {
2607   struct obj_section *sec = find_pc_section (ip);
2608   unw_dyn_info_t di;
2609   int ret;
2610   void *buf = NULL;
2611
2612   if (!sec)
2613     {
2614       /* XXX This only works if the host and the target architecture are
2615          both ia64 and if the have (more or less) the same kernel
2616          version.  */
2617       if (get_kernel_table (ip, &di) < 0)
2618         return -UNW_ENOINFO;
2619
2620       if (gdbarch_debug >= 1)
2621         fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: 0x%s -> "
2622                             "(name=`%s',segbase=0x%s,start=0x%s,end=0x%s,gp=0x%s,"
2623                             "length=%s,data=0x%s)\n",
2624                             paddr_nz (ip), (char *)di.u.ti.name_ptr,
2625                             paddr_nz (di.u.ti.segbase),
2626                             paddr_nz (di.start_ip), paddr_nz (di.end_ip),
2627                             paddr_nz (di.gp),
2628                             pulongest (di.u.ti.table_len),
2629                             paddr_nz ((CORE_ADDR)di.u.ti.table_data));
2630     }
2631   else
2632     {
2633       ret = ia64_find_unwind_table (sec->objfile, ip, &di, &buf);
2634       if (ret < 0)
2635         return ret;
2636
2637       if (gdbarch_debug >= 1)
2638         fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: 0x%s -> "
2639                             "(name=`%s',segbase=0x%s,start=0x%s,end=0x%s,gp=0x%s,"
2640                             "length=%s,data=0x%s)\n",
2641                             paddr_nz (ip), (char *)di.u.rti.name_ptr,
2642                             paddr_nz (di.u.rti.segbase),
2643                             paddr_nz (di.start_ip), paddr_nz (di.end_ip),
2644                             paddr_nz (di.gp),
2645                             pulongest (di.u.rti.table_len),
2646                             paddr_nz (di.u.rti.table_data));
2647     }
2648
2649   ret = libunwind_search_unwind_table (&as, ip, &di, pi, need_unwind_info,
2650                                        arg);
2651
2652   /* We no longer need the dyn info storage so free it.  */
2653   xfree (buf);
2654
2655   return ret;
2656 }
2657
2658 /* Libunwind callback accessor function for cleanup.  */
2659 static void
2660 ia64_put_unwind_info (unw_addr_space_t as,
2661                       unw_proc_info_t *pip, void *arg)
2662 {
2663   /* Nothing required for now.  */
2664 }
2665
2666 /* Libunwind callback accessor function to get head of the dynamic
2667    unwind-info registration list.  */
2668 static int
2669 ia64_get_dyn_info_list (unw_addr_space_t as,
2670                         unw_word_t *dilap, void *arg)
2671 {
2672   struct obj_section *text_sec;
2673   struct objfile *objfile;
2674   unw_word_t ip, addr;
2675   unw_dyn_info_t di;
2676   int ret;
2677
2678   if (!libunwind_is_initialized ())
2679     return -UNW_ENOINFO;
2680
2681   for (objfile = object_files; objfile; objfile = objfile->next)
2682     {
2683       void *buf = NULL;
2684
2685       text_sec = objfile->sections + SECT_OFF_TEXT (objfile);
2686       ip = obj_section_addr (text_sec);
2687       ret = ia64_find_unwind_table (objfile, ip, &di, &buf);
2688       if (ret >= 0)
2689         {
2690           addr = libunwind_find_dyn_list (as, &di, arg);
2691           /* We no longer need the dyn info storage so free it.  */
2692           xfree (buf);
2693
2694           if (addr)
2695             {
2696               if (gdbarch_debug >= 1)
2697                 fprintf_unfiltered (gdb_stdlog,
2698                                     "dynamic unwind table in objfile %s "
2699                                     "at 0x%s (gp=0x%s)\n",
2700                                     bfd_get_filename (objfile->obfd),
2701                                     paddr_nz (addr), paddr_nz (di.gp));
2702               *dilap = addr;
2703               return 0;
2704             }
2705         }
2706     }
2707   return -UNW_ENOINFO;
2708 }
2709
2710
2711 /* Frame interface functions for libunwind.  */
2712
2713 static void
2714 ia64_libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
2715                               struct frame_id *this_id)
2716 {
2717   struct frame_id id;
2718   char buf[8];
2719   CORE_ADDR bsp;
2720
2721
2722   libunwind_frame_this_id (this_frame, this_cache, &id);
2723   if (frame_id_eq (id, null_frame_id))
2724     {
2725       (*this_id) = null_frame_id;
2726       return;
2727     }
2728
2729   /* We must add the bsp as the special address for frame comparison
2730      purposes.  */
2731   get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
2732   bsp = extract_unsigned_integer (buf, 8);
2733
2734   (*this_id) = frame_id_build_special (id.stack_addr, id.code_addr, bsp);
2735
2736   if (gdbarch_debug >= 1)
2737     fprintf_unfiltered (gdb_stdlog,
2738                         "libunwind frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
2739                         paddr_nz (id.code_addr), paddr_nz (id.stack_addr),
2740                         paddr_nz (bsp),
2741                         host_address_to_string (this_frame));
2742 }
2743
2744 static struct value *
2745 ia64_libunwind_frame_prev_register (struct frame_info *this_frame,
2746                                     void **this_cache, int regnum)
2747 {
2748   int reg = regnum;
2749   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2750   struct value *val;
2751
2752   if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
2753     reg = IA64_PR_REGNUM;
2754   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
2755     reg = IA64_UNAT_REGNUM;
2756
2757   /* Let libunwind do most of the work.  */
2758   val = libunwind_frame_prev_register (this_frame, this_cache, reg);
2759
2760   if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
2761     {
2762       ULONGEST prN_val;
2763
2764       if (VP16_REGNUM <= regnum && regnum <= VP63_REGNUM)
2765         {
2766           int rrb_pr = 0;
2767           ULONGEST cfm;
2768           unsigned char buf[MAX_REGISTER_SIZE];
2769
2770           /* Fetch predicate register rename base from current frame
2771              marker for this frame.  */
2772           get_frame_register (this_frame, IA64_CFM_REGNUM, buf);
2773           cfm = extract_unsigned_integer (buf, 8);
2774           rrb_pr = (cfm >> 32) & 0x3f;
2775
2776           /* Adjust the register number to account for register rotation.  */
2777           regnum = VP16_REGNUM + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
2778         }
2779       prN_val = extract_bit_field (value_contents_all (val),
2780                                    regnum - VP0_REGNUM, 1);
2781       return frame_unwind_got_constant (this_frame, regnum, prN_val);
2782     }
2783
2784   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
2785     {
2786       ULONGEST unatN_val;
2787
2788       unatN_val = extract_bit_field (value_contents_all (val),
2789                                      regnum - IA64_NAT0_REGNUM, 1);
2790       return frame_unwind_got_constant (this_frame, regnum, unatN_val);
2791     }
2792
2793   else if (regnum == IA64_BSP_REGNUM)
2794     {
2795       struct value *cfm_val;
2796       CORE_ADDR prev_bsp, prev_cfm;
2797
2798       /* We want to calculate the previous bsp as the end of the previous
2799          register stack frame.  This corresponds to what the hardware bsp
2800          register will be if we pop the frame back which is why we might
2801          have been called.  We know that libunwind will pass us back the
2802          beginning of the current frame so we should just add sof to it. */
2803       prev_bsp = extract_unsigned_integer (value_contents_all (val), 8);
2804       cfm_val = libunwind_frame_prev_register (this_frame, this_cache,
2805                                                IA64_CFM_REGNUM);
2806       prev_cfm = extract_unsigned_integer (value_contents_all (cfm_val), 8);
2807       prev_bsp = rse_address_add (prev_bsp, (prev_cfm & 0x7f));
2808
2809       return frame_unwind_got_constant (this_frame, regnum, prev_bsp);
2810     }
2811   else
2812     return val;
2813 }
2814
2815 static int
2816 ia64_libunwind_frame_sniffer (const struct frame_unwind *self,
2817                               struct frame_info *this_frame,
2818                               void **this_cache)
2819 {
2820   if (libunwind_is_initialized ()
2821       && libunwind_frame_sniffer (self, this_frame, this_cache))
2822     return 1;
2823
2824   return 0;
2825 }
2826
2827 static const struct frame_unwind ia64_libunwind_frame_unwind =
2828 {
2829   NORMAL_FRAME,
2830   ia64_libunwind_frame_this_id,
2831   ia64_libunwind_frame_prev_register,
2832   NULL,
2833   ia64_libunwind_frame_sniffer,
2834   libunwind_frame_dealloc_cache
2835 };
2836
2837 static void
2838 ia64_libunwind_sigtramp_frame_this_id (struct frame_info *this_frame,
2839                                        void **this_cache,
2840                                        struct frame_id *this_id)
2841 {
2842   char buf[8];
2843   CORE_ADDR bsp;
2844   struct frame_id id;
2845   CORE_ADDR prev_ip;
2846
2847   libunwind_frame_this_id (this_frame, this_cache, &id);
2848   if (frame_id_eq (id, null_frame_id))
2849     {
2850       (*this_id) = null_frame_id;
2851       return;
2852     }
2853
2854   /* We must add the bsp as the special address for frame comparison
2855      purposes.  */
2856   get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
2857   bsp = extract_unsigned_integer (buf, 8);
2858
2859   /* For a sigtramp frame, we don't make the check for previous ip being 0.  */
2860   (*this_id) = frame_id_build_special (id.stack_addr, id.code_addr, bsp);
2861
2862   if (gdbarch_debug >= 1)
2863     fprintf_unfiltered (gdb_stdlog,
2864                         "libunwind sigtramp frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
2865                         paddr_nz (id.code_addr), paddr_nz (id.stack_addr),
2866                         paddr_nz (bsp),
2867                         host_address_to_string (this_frame));
2868 }
2869
2870 static struct value *
2871 ia64_libunwind_sigtramp_frame_prev_register (struct frame_info *this_frame,
2872                                              void **this_cache, int regnum)
2873 {
2874   struct value *prev_ip_val;
2875   CORE_ADDR prev_ip;
2876
2877   /* If the previous frame pc value is 0, then we want to use the SIGCONTEXT
2878      method of getting previous registers.  */
2879   prev_ip_val = libunwind_frame_prev_register (this_frame, this_cache,
2880                                                IA64_IP_REGNUM);
2881   prev_ip = extract_unsigned_integer (value_contents_all (prev_ip_val), 8);
2882
2883   if (prev_ip == 0)
2884     {
2885       void *tmp_cache = NULL;
2886       return ia64_sigtramp_frame_prev_register (this_frame, &tmp_cache,
2887                                                 regnum);
2888     }
2889   else
2890     return ia64_libunwind_frame_prev_register (this_frame, this_cache, regnum);
2891 }
2892
2893 static int
2894 ia64_libunwind_sigtramp_frame_sniffer (const struct frame_unwind *self,
2895                                        struct frame_info *this_frame,
2896                                        void **this_cache)
2897 {
2898   if (libunwind_is_initialized ())
2899     {
2900       if (libunwind_sigtramp_frame_sniffer (self, this_frame, this_cache))
2901         return 1;
2902       return 0;
2903     }
2904   else
2905     return ia64_sigtramp_frame_sniffer (self, this_frame, this_cache);
2906 }
2907
2908 static const struct frame_unwind ia64_libunwind_sigtramp_frame_unwind =
2909 {
2910   SIGTRAMP_FRAME,
2911   ia64_libunwind_sigtramp_frame_this_id,
2912   ia64_libunwind_sigtramp_frame_prev_register,
2913   NULL,
2914   ia64_libunwind_sigtramp_frame_sniffer
2915 };
2916
2917 /* Set of libunwind callback acccessor functions.  */
2918 static unw_accessors_t ia64_unw_accessors =
2919 {
2920   ia64_find_proc_info_x,
2921   ia64_put_unwind_info,
2922   ia64_get_dyn_info_list,
2923   ia64_access_mem,
2924   ia64_access_reg,
2925   ia64_access_fpreg,
2926   /* resume */
2927   /* get_proc_name */
2928 };
2929
2930 /* Set of special libunwind callback acccessor functions specific for accessing
2931    the rse registers.  At the top of the stack, we want libunwind to figure out
2932    how to read r32 - r127.  Though usually they are found sequentially in memory
2933    starting from $bof, this is not always true.  */
2934 static unw_accessors_t ia64_unw_rse_accessors =
2935 {
2936   ia64_find_proc_info_x,
2937   ia64_put_unwind_info,
2938   ia64_get_dyn_info_list,
2939   ia64_access_mem,
2940   ia64_access_rse_reg,
2941   ia64_access_rse_fpreg,
2942   /* resume */
2943   /* get_proc_name */
2944 };
2945
2946 /* Set of ia64 gdb libunwind-frame callbacks and data for generic libunwind-frame code to use.  */
2947 static struct libunwind_descr ia64_libunwind_descr =
2948 {
2949   ia64_gdb2uw_regnum,
2950   ia64_uw2gdb_regnum,
2951   ia64_is_fpreg,
2952   &ia64_unw_accessors,
2953   &ia64_unw_rse_accessors,
2954 };
2955
2956 #endif /* HAVE_LIBUNWIND_IA64_H  */
2957
2958 static int
2959 ia64_use_struct_convention (struct type *type)
2960 {
2961   struct type *float_elt_type;
2962
2963   /* Don't use the struct convention for anything but structure,
2964      union, or array types.  */
2965   if (!(TYPE_CODE (type) == TYPE_CODE_STRUCT
2966         || TYPE_CODE (type) == TYPE_CODE_UNION
2967         || TYPE_CODE (type) == TYPE_CODE_ARRAY))
2968     return 0;
2969
2970   /* HFAs are structures (or arrays) consisting entirely of floating
2971      point values of the same length.  Up to 8 of these are returned
2972      in registers.  Don't use the struct convention when this is the
2973      case.  */
2974   float_elt_type = is_float_or_hfa_type (type);
2975   if (float_elt_type != NULL
2976       && TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type) <= 8)
2977     return 0;
2978
2979   /* Other structs of length 32 or less are returned in r8-r11.
2980      Don't use the struct convention for those either.  */
2981   return TYPE_LENGTH (type) > 32;
2982 }
2983
2984 static void
2985 ia64_extract_return_value (struct type *type, struct regcache *regcache,
2986                            gdb_byte *valbuf)
2987 {
2988   struct type *float_elt_type;
2989
2990   float_elt_type = is_float_or_hfa_type (type);
2991   if (float_elt_type != NULL)
2992     {
2993       char from[MAX_REGISTER_SIZE];
2994       int offset = 0;
2995       int regnum = IA64_FR8_REGNUM;
2996       int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
2997
2998       while (n-- > 0)
2999         {
3000           regcache_cooked_read (regcache, regnum, from);
3001           convert_typed_floating (from, builtin_type_ia64_ext,
3002                                   (char *)valbuf + offset, float_elt_type);
3003           offset += TYPE_LENGTH (float_elt_type);
3004           regnum++;
3005         }
3006     }
3007   else
3008     {
3009       ULONGEST val;
3010       int offset = 0;
3011       int regnum = IA64_GR8_REGNUM;
3012       int reglen = TYPE_LENGTH (register_type (get_regcache_arch (regcache),
3013                                                IA64_GR8_REGNUM));
3014       int n = TYPE_LENGTH (type) / reglen;
3015       int m = TYPE_LENGTH (type) % reglen;
3016
3017       while (n-- > 0)
3018         {
3019           ULONGEST val;
3020           regcache_cooked_read_unsigned (regcache, regnum, &val);
3021           memcpy ((char *)valbuf + offset, &val, reglen);
3022           offset += reglen;
3023           regnum++;
3024         }
3025
3026       if (m)
3027         {
3028           regcache_cooked_read_unsigned (regcache, regnum, &val);
3029           memcpy ((char *)valbuf + offset, &val, m);
3030         }
3031     }
3032 }
3033
3034 static void
3035 ia64_store_return_value (struct type *type, struct regcache *regcache,
3036                          const gdb_byte *valbuf)
3037 {
3038   struct type *float_elt_type;
3039
3040   float_elt_type = is_float_or_hfa_type (type);
3041   if (float_elt_type != NULL)
3042     {
3043       char to[MAX_REGISTER_SIZE];
3044       int offset = 0;
3045       int regnum = IA64_FR8_REGNUM;
3046       int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
3047
3048       while (n-- > 0)
3049         {
3050           convert_typed_floating ((char *)valbuf + offset, float_elt_type,
3051                                   to, builtin_type_ia64_ext);
3052           regcache_cooked_write (regcache, regnum, to);
3053           offset += TYPE_LENGTH (float_elt_type);
3054           regnum++;
3055         }
3056     }
3057   else
3058     {
3059       ULONGEST val;
3060       int offset = 0;
3061       int regnum = IA64_GR8_REGNUM;
3062       int reglen = TYPE_LENGTH (register_type (get_regcache_arch (regcache),
3063                                                IA64_GR8_REGNUM));
3064       int n = TYPE_LENGTH (type) / reglen;
3065       int m = TYPE_LENGTH (type) % reglen;
3066
3067       while (n-- > 0)
3068         {
3069           ULONGEST val;
3070           memcpy (&val, (char *)valbuf + offset, reglen);
3071           regcache_cooked_write_unsigned (regcache, regnum, val);
3072           offset += reglen;
3073           regnum++;
3074         }
3075
3076       if (m)
3077         {
3078           memcpy (&val, (char *)valbuf + offset, m);
3079           regcache_cooked_write_unsigned (regcache, regnum, val);
3080         }
3081     }
3082 }
3083
3084 static enum return_value_convention
3085 ia64_return_value (struct gdbarch *gdbarch, struct type *func_type,
3086                    struct type *valtype, struct regcache *regcache,
3087                    gdb_byte *readbuf, const gdb_byte *writebuf)
3088 {
3089   int struct_return = ia64_use_struct_convention (valtype);
3090
3091   if (writebuf != NULL)
3092     {
3093       gdb_assert (!struct_return);
3094       ia64_store_return_value (valtype, regcache, writebuf);
3095     }
3096
3097   if (readbuf != NULL)
3098     {
3099       gdb_assert (!struct_return);
3100       ia64_extract_return_value (valtype, regcache, readbuf);
3101     }
3102
3103   if (struct_return)
3104     return RETURN_VALUE_STRUCT_CONVENTION;
3105   else
3106     return RETURN_VALUE_REGISTER_CONVENTION;
3107 }
3108
3109 static int
3110 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
3111 {
3112   switch (TYPE_CODE (t))
3113     {
3114     case TYPE_CODE_FLT:
3115       if (*etp)
3116         return TYPE_LENGTH (*etp) == TYPE_LENGTH (t);
3117       else
3118         {
3119           *etp = t;
3120           return 1;
3121         }
3122       break;
3123     case TYPE_CODE_ARRAY:
3124       return
3125         is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t)),
3126                                       etp);
3127       break;
3128     case TYPE_CODE_STRUCT:
3129       {
3130         int i;
3131
3132         for (i = 0; i < TYPE_NFIELDS (t); i++)
3133           if (!is_float_or_hfa_type_recurse
3134               (check_typedef (TYPE_FIELD_TYPE (t, i)), etp))
3135             return 0;
3136         return 1;
3137       }
3138       break;
3139     default:
3140       return 0;
3141       break;
3142     }
3143 }
3144
3145 /* Determine if the given type is one of the floating point types or
3146    and HFA (which is a struct, array, or combination thereof whose
3147    bottom-most elements are all of the same floating point type).  */
3148
3149 static struct type *
3150 is_float_or_hfa_type (struct type *t)
3151 {
3152   struct type *et = 0;
3153
3154   return is_float_or_hfa_type_recurse (t, &et) ? et : 0;
3155 }
3156
3157
3158 /* Return 1 if the alignment of T is such that the next even slot
3159    should be used.  Return 0, if the next available slot should
3160    be used.  (See section 8.5.1 of the IA-64 Software Conventions
3161    and Runtime manual).  */
3162
3163 static int
3164 slot_alignment_is_next_even (struct type *t)
3165 {
3166   switch (TYPE_CODE (t))
3167     {
3168     case TYPE_CODE_INT:
3169     case TYPE_CODE_FLT:
3170       if (TYPE_LENGTH (t) > 8)
3171         return 1;
3172       else
3173         return 0;
3174     case TYPE_CODE_ARRAY:
3175       return
3176         slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t)));
3177     case TYPE_CODE_STRUCT:
3178       {
3179         int i;
3180
3181         for (i = 0; i < TYPE_NFIELDS (t); i++)
3182           if (slot_alignment_is_next_even
3183               (check_typedef (TYPE_FIELD_TYPE (t, i))))
3184             return 1;
3185         return 0;
3186       }
3187     default:
3188       return 0;
3189     }
3190 }
3191
3192 /* Attempt to find (and return) the global pointer for the given
3193    function.
3194
3195    This is a rather nasty bit of code searchs for the .dynamic section
3196    in the objfile corresponding to the pc of the function we're trying
3197    to call.  Once it finds the addresses at which the .dynamic section
3198    lives in the child process, it scans the Elf64_Dyn entries for a
3199    DT_PLTGOT tag.  If it finds one of these, the corresponding
3200    d_un.d_ptr value is the global pointer.  */
3201
3202 static CORE_ADDR
3203 ia64_find_global_pointer (CORE_ADDR faddr)
3204 {
3205   struct obj_section *faddr_sect;
3206
3207   faddr_sect = find_pc_section (faddr);
3208   if (faddr_sect != NULL)
3209     {
3210       struct obj_section *osect;
3211
3212       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
3213         {
3214           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
3215             break;
3216         }
3217
3218       if (osect < faddr_sect->objfile->sections_end)
3219         {
3220           CORE_ADDR addr, endaddr;
3221
3222           addr = obj_section_addr (osect);
3223           endaddr = obj_section_endaddr (osect);
3224
3225           while (addr < endaddr)
3226             {
3227               int status;
3228               LONGEST tag;
3229               char buf[8];
3230
3231               status = target_read_memory (addr, buf, sizeof (buf));
3232               if (status != 0)
3233                 break;
3234               tag = extract_signed_integer (buf, sizeof (buf));
3235
3236               if (tag == DT_PLTGOT)
3237                 {
3238                   CORE_ADDR global_pointer;
3239
3240                   status = target_read_memory (addr + 8, buf, sizeof (buf));
3241                   if (status != 0)
3242                     break;
3243                   global_pointer = extract_unsigned_integer (buf, sizeof (buf));
3244
3245                   /* The payoff... */
3246                   return global_pointer;
3247                 }
3248
3249               if (tag == DT_NULL)
3250                 break;
3251
3252               addr += 16;
3253             }
3254         }
3255     }
3256   return 0;
3257 }
3258
3259 /* Given a function's address, attempt to find (and return) the
3260    corresponding (canonical) function descriptor.  Return 0 if
3261    not found.  */
3262 static CORE_ADDR
3263 find_extant_func_descr (CORE_ADDR faddr)
3264 {
3265   struct obj_section *faddr_sect;
3266
3267   /* Return early if faddr is already a function descriptor.  */
3268   faddr_sect = find_pc_section (faddr);
3269   if (faddr_sect && strcmp (faddr_sect->the_bfd_section->name, ".opd") == 0)
3270     return faddr;
3271
3272   if (faddr_sect != NULL)
3273     {
3274       struct obj_section *osect;
3275       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
3276         {
3277           if (strcmp (osect->the_bfd_section->name, ".opd") == 0)
3278             break;
3279         }
3280
3281       if (osect < faddr_sect->objfile->sections_end)
3282         {
3283           CORE_ADDR addr, endaddr;
3284
3285           addr = obj_section_addr (osect);
3286           endaddr = obj_section_endaddr (osect);
3287
3288           while (addr < endaddr)
3289             {
3290               int status;
3291               LONGEST faddr2;
3292               char buf[8];
3293
3294               status = target_read_memory (addr, buf, sizeof (buf));
3295               if (status != 0)
3296                 break;
3297               faddr2 = extract_signed_integer (buf, sizeof (buf));
3298
3299               if (faddr == faddr2)
3300                 return addr;
3301
3302               addr += 16;
3303             }
3304         }
3305     }
3306   return 0;
3307 }
3308
3309 /* Attempt to find a function descriptor corresponding to the
3310    given address.  If none is found, construct one on the
3311    stack using the address at fdaptr.  */
3312
3313 static CORE_ADDR
3314 find_func_descr (struct regcache *regcache, CORE_ADDR faddr, CORE_ADDR *fdaptr)
3315 {
3316   CORE_ADDR fdesc;
3317
3318   fdesc = find_extant_func_descr (faddr);
3319
3320   if (fdesc == 0)
3321     {
3322       ULONGEST global_pointer;
3323       char buf[16];
3324
3325       fdesc = *fdaptr;
3326       *fdaptr += 16;
3327
3328       global_pointer = ia64_find_global_pointer (faddr);
3329
3330       if (global_pointer == 0)
3331         regcache_cooked_read_unsigned (regcache,
3332                                        IA64_GR1_REGNUM, &global_pointer);
3333
3334       store_unsigned_integer (buf, 8, faddr);
3335       store_unsigned_integer (buf + 8, 8, global_pointer);
3336
3337       write_memory (fdesc, buf, 16);
3338     }
3339
3340   return fdesc;
3341 }
3342
3343 /* Use the following routine when printing out function pointers
3344    so the user can see the function address rather than just the
3345    function descriptor.  */
3346 static CORE_ADDR
3347 ia64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
3348                                  struct target_ops *targ)
3349 {
3350   struct obj_section *s;
3351
3352   s = find_pc_section (addr);
3353
3354   /* check if ADDR points to a function descriptor.  */
3355   if (s && strcmp (s->the_bfd_section->name, ".opd") == 0)
3356     return read_memory_unsigned_integer (addr, 8);
3357
3358   /* Normally, functions live inside a section that is executable.
3359      So, if ADDR points to a non-executable section, then treat it
3360      as a function descriptor and return the target address iff
3361      the target address itself points to a section that is executable.  */
3362   if (s && (s->the_bfd_section->flags & SEC_CODE) == 0)
3363     {
3364       CORE_ADDR pc = read_memory_unsigned_integer (addr, 8);
3365       struct obj_section *pc_section = find_pc_section (pc);
3366
3367       if (pc_section && (pc_section->the_bfd_section->flags & SEC_CODE))
3368         return pc;
3369     }
3370
3371   /* There are also descriptors embedded in vtables.  */
3372   if (s)
3373     {
3374       struct minimal_symbol *minsym;
3375
3376       minsym = lookup_minimal_symbol_by_pc (addr);
3377
3378       if (minsym && is_vtable_name (SYMBOL_LINKAGE_NAME (minsym)))
3379         return read_memory_unsigned_integer (addr, 8);
3380     }
3381
3382   return addr;
3383 }
3384
3385 static CORE_ADDR
3386 ia64_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
3387 {
3388   return sp & ~0xfLL;
3389 }
3390
3391 static CORE_ADDR
3392 ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
3393                       struct regcache *regcache, CORE_ADDR bp_addr,
3394                       int nargs, struct value **args, CORE_ADDR sp,
3395                       int struct_return, CORE_ADDR struct_addr)
3396 {
3397   int argno;
3398   struct value *arg;
3399   struct type *type;
3400   int len, argoffset;
3401   int nslots, rseslots, memslots, slotnum, nfuncargs;
3402   int floatreg;
3403   ULONGEST bsp, cfm, pfs, new_bsp;
3404   CORE_ADDR funcdescaddr, pc, global_pointer;
3405   CORE_ADDR func_addr = find_function_addr (function, NULL);
3406
3407   nslots = 0;
3408   nfuncargs = 0;
3409   /* Count the number of slots needed for the arguments.  */
3410   for (argno = 0; argno < nargs; argno++)
3411     {
3412       arg = args[argno];
3413       type = check_typedef (value_type (arg));
3414       len = TYPE_LENGTH (type);
3415
3416       if ((nslots & 1) && slot_alignment_is_next_even (type))
3417         nslots++;
3418
3419       if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3420         nfuncargs++;
3421
3422       nslots += (len + 7) / 8;
3423     }
3424
3425   /* Divvy up the slots between the RSE and the memory stack.  */
3426   rseslots = (nslots > 8) ? 8 : nslots;
3427   memslots = nslots - rseslots;
3428
3429   /* Allocate a new RSE frame.  */
3430   regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
3431
3432   regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
3433   new_bsp = rse_address_add (bsp, rseslots);
3434   regcache_cooked_write_unsigned (regcache, IA64_BSP_REGNUM, new_bsp);
3435
3436   regcache_cooked_read_unsigned (regcache, IA64_PFS_REGNUM, &pfs);
3437   pfs &= 0xc000000000000000LL;
3438   pfs |= (cfm & 0xffffffffffffLL);
3439   regcache_cooked_write_unsigned (regcache, IA64_PFS_REGNUM, pfs);
3440
3441   cfm &= 0xc000000000000000LL;
3442   cfm |= rseslots;
3443   regcache_cooked_write_unsigned (regcache, IA64_CFM_REGNUM, cfm);
3444
3445   /* We will attempt to find function descriptors in the .opd segment,
3446      but if we can't we'll construct them ourselves.  That being the
3447      case, we'll need to reserve space on the stack for them.  */
3448   funcdescaddr = sp - nfuncargs * 16;
3449   funcdescaddr &= ~0xfLL;
3450
3451   /* Adjust the stack pointer to it's new value.  The calling conventions
3452      require us to have 16 bytes of scratch, plus whatever space is
3453      necessary for the memory slots and our function descriptors.  */
3454   sp = sp - 16 - (memslots + nfuncargs) * 8;
3455   sp &= ~0xfLL;                         /* Maintain 16 byte alignment.  */
3456
3457   /* Place the arguments where they belong.  The arguments will be
3458      either placed in the RSE backing store or on the memory stack.
3459      In addition, floating point arguments or HFAs are placed in
3460      floating point registers.  */
3461   slotnum = 0;
3462   floatreg = IA64_FR8_REGNUM;
3463   for (argno = 0; argno < nargs; argno++)
3464     {
3465       struct type *float_elt_type;
3466
3467       arg = args[argno];
3468       type = check_typedef (value_type (arg));
3469       len = TYPE_LENGTH (type);
3470
3471       /* Special handling for function parameters.  */
3472       if (len == 8
3473           && TYPE_CODE (type) == TYPE_CODE_PTR
3474           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
3475         {
3476           char val_buf[8];
3477           ULONGEST faddr = extract_unsigned_integer (value_contents (arg), 8);
3478           store_unsigned_integer (val_buf, 8,
3479                                   find_func_descr (regcache, faddr,
3480                                                    &funcdescaddr));
3481           if (slotnum < rseslots)
3482             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
3483           else
3484             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
3485           slotnum++;
3486           continue;
3487         }
3488
3489       /* Normal slots.  */
3490
3491       /* Skip odd slot if necessary...  */
3492       if ((slotnum & 1) && slot_alignment_is_next_even (type))
3493         slotnum++;
3494
3495       argoffset = 0;
3496       while (len > 0)
3497         {
3498           char val_buf[8];
3499
3500           memset (val_buf, 0, 8);
3501           memcpy (val_buf, value_contents (arg) + argoffset, (len > 8) ? 8 : len);
3502
3503           if (slotnum < rseslots)
3504             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
3505           else
3506             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
3507
3508           argoffset += 8;
3509           len -= 8;
3510           slotnum++;
3511         }
3512
3513       /* Handle floating point types (including HFAs).  */
3514       float_elt_type = is_float_or_hfa_type (type);
3515       if (float_elt_type != NULL)
3516         {
3517           argoffset = 0;
3518           len = TYPE_LENGTH (type);
3519           while (len > 0 && floatreg < IA64_FR16_REGNUM)
3520             {
3521               char to[MAX_REGISTER_SIZE];
3522               convert_typed_floating (value_contents (arg) + argoffset, float_elt_type,
3523                                       to, builtin_type_ia64_ext);
3524               regcache_cooked_write (regcache, floatreg, (void *)to);
3525               floatreg++;
3526               argoffset += TYPE_LENGTH (float_elt_type);
3527               len -= TYPE_LENGTH (float_elt_type);
3528             }
3529         }
3530     }
3531
3532   /* Store the struct return value in r8 if necessary.  */
3533   if (struct_return)
3534     {
3535       regcache_cooked_write_unsigned (regcache, IA64_GR8_REGNUM, (ULONGEST)struct_addr);
3536     }
3537
3538   global_pointer = ia64_find_global_pointer (func_addr);
3539
3540   if (global_pointer != 0)
3541     regcache_cooked_write_unsigned (regcache, IA64_GR1_REGNUM, global_pointer);
3542
3543   regcache_cooked_write_unsigned (regcache, IA64_BR0_REGNUM, bp_addr);
3544
3545   regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
3546
3547   return sp;
3548 }
3549
3550 static struct frame_id
3551 ia64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
3552 {
3553   char buf[8];
3554   CORE_ADDR sp, bsp;
3555
3556   get_frame_register (this_frame, sp_regnum, buf);
3557   sp = extract_unsigned_integer (buf, 8);
3558
3559   get_frame_register (this_frame, IA64_BSP_REGNUM, buf);
3560   bsp = extract_unsigned_integer (buf, 8);
3561
3562   if (gdbarch_debug >= 1)
3563     fprintf_unfiltered (gdb_stdlog,
3564                         "dummy frame id: code 0x%s, stack 0x%s, special 0x%s\n",
3565                         paddr_nz (get_frame_pc (this_frame)),
3566                         paddr_nz (sp), paddr_nz (bsp));
3567
3568   return frame_id_build_special (sp, get_frame_pc (this_frame), bsp);
3569 }
3570
3571 static CORE_ADDR
3572 ia64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
3573 {
3574   char buf[8];
3575   CORE_ADDR ip, psr, pc;
3576
3577   frame_unwind_register (next_frame, IA64_IP_REGNUM, buf);
3578   ip = extract_unsigned_integer (buf, 8);
3579   frame_unwind_register (next_frame, IA64_PSR_REGNUM, buf);
3580   psr = extract_unsigned_integer (buf, 8);
3581
3582   pc = (ip & ~0xf) | ((psr >> 41) & 3);
3583   return pc;
3584 }
3585
3586 static int
3587 ia64_print_insn (bfd_vma memaddr, struct disassemble_info *info)
3588 {
3589   info->bytes_per_line = SLOT_MULTIPLIER;
3590   return print_insn_ia64 (memaddr, info);
3591 }
3592
3593 static struct gdbarch *
3594 ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3595 {
3596   struct gdbarch *gdbarch;
3597   struct gdbarch_tdep *tdep;
3598
3599   /* If there is already a candidate, use it.  */
3600   arches = gdbarch_list_lookup_by_info (arches, &info);
3601   if (arches != NULL)
3602     return arches->gdbarch;
3603
3604   tdep = xmalloc (sizeof (struct gdbarch_tdep));
3605   gdbarch = gdbarch_alloc (&info, tdep);
3606
3607   tdep->sigcontext_register_address = 0;
3608   tdep->pc_in_sigtramp = 0;
3609
3610   /* According to the ia64 specs, instructions that store long double
3611      floats in memory use a long-double format different than that
3612      used in the floating registers.  The memory format matches the
3613      x86 extended float format which is 80 bits.  An OS may choose to
3614      use this format (e.g. GNU/Linux) or choose to use a different
3615      format for storing long doubles (e.g. HPUX).  In the latter case,
3616      the setting of the format may be moved/overridden in an
3617      OS-specific tdep file.  */
3618   set_gdbarch_long_double_format (gdbarch, floatformats_i387_ext);
3619
3620   set_gdbarch_short_bit (gdbarch, 16);
3621   set_gdbarch_int_bit (gdbarch, 32);
3622   set_gdbarch_long_bit (gdbarch, 64);
3623   set_gdbarch_long_long_bit (gdbarch, 64);
3624   set_gdbarch_float_bit (gdbarch, 32);
3625   set_gdbarch_double_bit (gdbarch, 64);
3626   set_gdbarch_long_double_bit (gdbarch, 128);
3627   set_gdbarch_ptr_bit (gdbarch, 64);
3628
3629   set_gdbarch_num_regs (gdbarch, NUM_IA64_RAW_REGS);
3630   set_gdbarch_num_pseudo_regs (gdbarch, LAST_PSEUDO_REGNUM - FIRST_PSEUDO_REGNUM);
3631   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
3632   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
3633
3634   set_gdbarch_register_name (gdbarch, ia64_register_name);
3635   set_gdbarch_register_type (gdbarch, ia64_register_type);
3636
3637   set_gdbarch_pseudo_register_read (gdbarch, ia64_pseudo_register_read);
3638   set_gdbarch_pseudo_register_write (gdbarch, ia64_pseudo_register_write);
3639   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, ia64_dwarf_reg_to_regnum);
3640   set_gdbarch_register_reggroup_p (gdbarch, ia64_register_reggroup_p);
3641   set_gdbarch_convert_register_p (gdbarch, ia64_convert_register_p);
3642   set_gdbarch_register_to_value (gdbarch, ia64_register_to_value);
3643   set_gdbarch_value_to_register (gdbarch, ia64_value_to_register);
3644
3645   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
3646
3647   set_gdbarch_return_value (gdbarch, ia64_return_value);
3648
3649   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
3650   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
3651   set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc);
3652   set_gdbarch_read_pc (gdbarch, ia64_read_pc);
3653   set_gdbarch_write_pc (gdbarch, ia64_write_pc);
3654
3655   /* Settings for calling functions in the inferior.  */
3656   set_gdbarch_push_dummy_call (gdbarch, ia64_push_dummy_call);
3657   set_gdbarch_frame_align (gdbarch, ia64_frame_align);
3658   set_gdbarch_dummy_id (gdbarch, ia64_dummy_id);
3659
3660   set_gdbarch_unwind_pc (gdbarch, ia64_unwind_pc);
3661 #ifdef HAVE_LIBUNWIND_IA64_H
3662   frame_unwind_append_unwinder (gdbarch,
3663                                 &ia64_libunwind_sigtramp_frame_unwind);
3664   frame_unwind_append_unwinder (gdbarch, &ia64_libunwind_frame_unwind);
3665   frame_unwind_append_unwinder (gdbarch, &ia64_sigtramp_frame_unwind);
3666   libunwind_frame_set_descr (gdbarch, &ia64_libunwind_descr);
3667 #else
3668   frame_unwind_append_unwinder (gdbarch, &ia64_sigtramp_frame_unwind);
3669 #endif
3670   frame_unwind_append_unwinder (gdbarch, &ia64_frame_unwind);
3671   frame_base_set_default (gdbarch, &ia64_frame_base);
3672
3673   /* Settings that should be unnecessary.  */
3674   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3675
3676   set_gdbarch_print_insn (gdbarch, ia64_print_insn);
3677   set_gdbarch_convert_from_func_ptr_addr (gdbarch, ia64_convert_from_func_ptr_addr);
3678
3679   /* The virtual table contains 16-byte descriptors, not pointers to
3680      descriptors.  */
3681   set_gdbarch_vtable_function_descriptors (gdbarch, 1);
3682
3683   /* Hook in ABI-specific overrides, if they have been registered.  */
3684   gdbarch_init_osabi (info, gdbarch);
3685
3686   return gdbarch;
3687 }
3688
3689 extern initialize_file_ftype _initialize_ia64_tdep; /* -Wmissing-prototypes */
3690
3691 void
3692 _initialize_ia64_tdep (void)
3693 {
3694   /* Define the ia64 floating-point format to gdb.  */
3695   builtin_type_ia64_ext =
3696     init_type (TYPE_CODE_FLT, 128 / 8,
3697                0, "builtin_type_ia64_ext", NULL);
3698   TYPE_FLOATFORMAT (builtin_type_ia64_ext) = floatformats_ia64_ext;
3699
3700   gdbarch_register (bfd_arch_ia64, ia64_gdbarch_init, NULL);
3701 }