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