gdb/ia64-tdep.c

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