gdb/ia64-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2
   3    Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "symfile.h"            /* for entry_point_address */
  25 #include "gdbcore.h"
  26 #include "arch-utils.h"
  27 #include "floatformat.h"
  28 #include "regcache.h"
  29 #include "doublest.h"
  30 #include "value.h"
  31 #include "gdb_assert.h"
  32 #include "objfiles.h"
  33 #include "elf/common.h"         /* for DT_PLTGOT value */
  34 #include "elf-bfd.h"
  35
  36 /* Hook for determining the global pointer when calling functions in
  37    the inferior under AIX.  The initialization code in ia64-aix-nat.c
  38    sets this hook to the address of a function which will find the
  39    global pointer for a given address.
  40
  41    The generic code which uses the dynamic section in the inferior for
  42    finding the global pointer is not of much use on AIX since the
  43    values obtained from the inferior have not been relocated.  */
  44
  45 CORE_ADDR (*native_find_global_pointer) (CORE_ADDR) = 0;
  46
  47 /* An enumeration of the different IA-64 instruction types.  */
  48
  49 typedef enum instruction_type
  50 {
  51   A,                    /* Integer ALU ;    I-unit or M-unit */
  52   I,                    /* Non-ALU integer; I-unit */
  53   M,                    /* Memory ;         M-unit */
  54   F,                    /* Floating-point ; F-unit */
  55   B,                    /* Branch ;         B-unit */
  56   L,                    /* Extended (L+X) ; I-unit */
  57   X,                    /* Extended (L+X) ; I-unit */
  58   undefined             /* undefined or reserved */
  59 } instruction_type;
  60
  61 /* We represent IA-64 PC addresses as the value of the instruction
  62    pointer or'd with some bit combination in the low nibble which
  63    represents the slot number in the bundle addressed by the
  64    instruction pointer.  The problem is that the Linux kernel
  65    multiplies its slot numbers (for exceptions) by one while the
  66    disassembler multiplies its slot numbers by 6.  In addition, I've
  67    heard it said that the simulator uses 1 as the multiplier.
  68
  69    I've fixed the disassembler so that the bytes_per_line field will
  70    be the slot multiplier.  If bytes_per_line comes in as zero, it
  71    is set to six (which is how it was set up initially). -- objdump
  72    displays pretty disassembly dumps with this value.  For our purposes,
  73    we'll set bytes_per_line to SLOT_MULTIPLIER. This is okay since we
  74    never want to also display the raw bytes the way objdump does. */
  75
  76 #define SLOT_MULTIPLIER 1
  77
  78 /* Length in bytes of an instruction bundle */
  79
  80 #define BUNDLE_LEN 16
  81
  82 /* FIXME: These extern declarations should go in ia64-tdep.h.  */
  83 extern CORE_ADDR ia64_linux_sigcontext_register_address (CORE_ADDR, int);
  84 extern CORE_ADDR ia64_aix_sigcontext_register_address (CORE_ADDR, int);
  85
  86 static gdbarch_init_ftype ia64_gdbarch_init;
  87
  88 static gdbarch_register_name_ftype ia64_register_name;
  89 static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc;
  90 static gdbarch_skip_prologue_ftype ia64_skip_prologue;
  91 static gdbarch_deprecated_extract_return_value_ftype ia64_extract_return_value;
  92 static gdbarch_deprecated_extract_struct_value_address_ftype ia64_extract_struct_value_address;
  93 static gdbarch_use_struct_convention_ftype ia64_use_struct_convention;
  94 static gdbarch_frameless_function_invocation_ftype ia64_frameless_function_invocation;
  95 static gdbarch_deprecated_saved_pc_after_call_ftype ia64_saved_pc_after_call;
  96 static void ia64_pop_frame_regular (struct frame_info *frame);
  97 static struct type *is_float_or_hfa_type (struct type *t);
  98
  99 static int ia64_num_regs = 590;
 100
 101 static int pc_regnum = IA64_IP_REGNUM;
 102 static int sp_regnum = IA64_GR12_REGNUM;
 103 static int fp_regnum = IA64_VFP_REGNUM;
 104 static int lr_regnum = IA64_VRAP_REGNUM;
 105
 106 static LONGEST ia64_call_dummy_words[] = {0};
 107
 108 /* Array of register names; There should be ia64_num_regs strings in
 109    the initializer.  */
 110
 111 static char *ia64_register_names[] =
 112 { "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 113   "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 114   "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
 115   "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
 116   "r32",  "r33",  "r34",  "r35",  "r36",  "r37",  "r38",  "r39",
 117   "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
 118   "r48",  "r49",  "r50",  "r51",  "r52",  "r53",  "r54",  "r55",
 119   "r56",  "r57",  "r58",  "r59",  "r60",  "r61",  "r62",  "r63",
 120   "r64",  "r65",  "r66",  "r67",  "r68",  "r69",  "r70",  "r71",
 121   "r72",  "r73",  "r74",  "r75",  "r76",  "r77",  "r78",  "r79",
 122   "r80",  "r81",  "r82",  "r83",  "r84",  "r85",  "r86",  "r87",
 123   "r88",  "r89",  "r90",  "r91",  "r92",  "r93",  "r94",  "r95",
 124   "r96",  "r97",  "r98",  "r99",  "r100", "r101", "r102", "r103",
 125   "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
 126   "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
 127   "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
 128
 129   "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
 130   "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
 131   "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
 132   "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",
 133   "f32",  "f33",  "f34",  "f35",  "f36",  "f37",  "f38",  "f39",
 134   "f40",  "f41",  "f42",  "f43",  "f44",  "f45",  "f46",  "f47",
 135   "f48",  "f49",  "f50",  "f51",  "f52",  "f53",  "f54",  "f55",
 136   "f56",  "f57",  "f58",  "f59",  "f60",  "f61",  "f62",  "f63",
 137   "f64",  "f65",  "f66",  "f67",  "f68",  "f69",  "f70",  "f71",
 138   "f72",  "f73",  "f74",  "f75",  "f76",  "f77",  "f78",  "f79",
 139   "f80",  "f81",  "f82",  "f83",  "f84",  "f85",  "f86",  "f87",
 140   "f88",  "f89",  "f90",  "f91",  "f92",  "f93",  "f94",  "f95",
 141   "f96",  "f97",  "f98",  "f99",  "f100", "f101", "f102", "f103",
 142   "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
 143   "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
 144   "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
 145
 146   "p0",   "p1",   "p2",   "p3",   "p4",   "p5",   "p6",   "p7",
 147   "p8",   "p9",   "p10",  "p11",  "p12",  "p13",  "p14",  "p15",
 148   "p16",  "p17",  "p18",  "p19",  "p20",  "p21",  "p22",  "p23",
 149   "p24",  "p25",  "p26",  "p27",  "p28",  "p29",  "p30",  "p31",
 150   "p32",  "p33",  "p34",  "p35",  "p36",  "p37",  "p38",  "p39",
 151   "p40",  "p41",  "p42",  "p43",  "p44",  "p45",  "p46",  "p47",
 152   "p48",  "p49",  "p50",  "p51",  "p52",  "p53",  "p54",  "p55",
 153   "p56",  "p57",  "p58",  "p59",  "p60",  "p61",  "p62",  "p63",
 154
 155   "b0",   "b1",   "b2",   "b3",   "b4",   "b5",   "b6",   "b7",
 156
 157   "vfp", "vrap",
 158
 159   "pr", "ip", "psr", "cfm",
 160
 161   "kr0",   "kr1",   "kr2",   "kr3",   "kr4",   "kr5",   "kr6",   "kr7",
 162   "", "", "", "", "", "", "", "",
 163   "rsc", "bsp", "bspstore", "rnat",
 164   "", "fcr", "", "",
 165   "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr",  "",
 166   "ccv", "", "", "", "unat", "", "", "",
 167   "fpsr", "", "", "", "itc",
 168   "", "", "", "", "", "", "", "", "", "",
 169   "", "", "", "", "", "", "", "", "",
 170   "pfs", "lc", "ec",
 171   "", "", "", "", "", "", "", "", "", "",
 172   "", "", "", "", "", "", "", "", "", "",
 173   "", "", "", "", "", "", "", "", "", "",
 174   "", "", "", "", "", "", "", "", "", "",
 175   "", "", "", "", "", "", "", "", "", "",
 176   "", "", "", "", "", "", "", "", "", "",
 177   "",
 178   "nat0",  "nat1",  "nat2",  "nat3",  "nat4",  "nat5",  "nat6",  "nat7",
 179   "nat8",  "nat9",  "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
 180   "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
 181   "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
 182   "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
 183   "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
 184   "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
 185   "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
 186   "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
 187   "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
 188   "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
 189   "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
 190   "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
 191   "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
 192   "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
 193   "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
 194 };
 195
 196 struct frame_extra_info
 197   {
 198     CORE_ADDR bsp;      /* points at r32 for the current frame */
 199     CORE_ADDR cfm;      /* cfm value for current frame */
 200     int sof;            /* Size of frame  (decoded from cfm value) */
 201     int sol;            /* Size of locals (decoded from cfm value) */
 202     CORE_ADDR after_prologue;
 203                         /* Address of first instruction after the last
 204                            prologue instruction;  Note that there may
 205                            be instructions from the function's body
 206                            intermingled with the prologue. */
 207     int mem_stack_frame_size;
 208                         /* Size of the memory stack frame (may be zero),
 209                            or -1 if it has not been determined yet. */
 210     int fp_reg;         /* Register number (if any) used a frame pointer
 211                            for this frame.  0 if no register is being used
 212                            as the frame pointer. */
 213   };
 214
 215 struct gdbarch_tdep
 216   {
 217     int os_ident;       /* From the ELF header, one of the ELFOSABI_
 218                            constants: ELFOSABI_LINUX, ELFOSABI_AIX,
 219                            etc. */
 220     CORE_ADDR (*sigcontext_register_address) (CORE_ADDR, int);
 221                         /* OS specific function which, given a frame address
 222                            and register number, returns the offset to the
 223                            given register from the start of the frame. */
 224     CORE_ADDR (*find_global_pointer) (CORE_ADDR);
 225   };
 226
 227 #define SIGCONTEXT_REGISTER_ADDRESS \
 228   (gdbarch_tdep (current_gdbarch)->sigcontext_register_address)
 229 #define FIND_GLOBAL_POINTER \
 230   (gdbarch_tdep (current_gdbarch)->find_global_pointer)
 231
 232 static const char *
 233 ia64_register_name (int reg)
 234 {
 235   return ia64_register_names[reg];
 236 }
 237
 238 static int
 239 ia64_register_raw_size (int reg)
 240 {
 241   return (IA64_FR0_REGNUM <= reg && reg <= IA64_FR127_REGNUM) ? 16 : 8;
 242 }
 243
 244 static int
 245 ia64_register_virtual_size (int reg)
 246 {
 247   return (IA64_FR0_REGNUM <= reg && reg <= IA64_FR127_REGNUM) ? 16 : 8;
 248 }
 249
 250 /* Return true iff register N's virtual format is different from
 251    its raw format. */
 252 static int
 253 ia64_register_convertible (int nr)
 254 {
 255   return (IA64_FR0_REGNUM <= nr && nr <= IA64_FR127_REGNUM);
 256 }
 257
 258 const struct floatformat floatformat_ia64_ext =
 259 {
 260   floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 261   floatformat_intbit_yes
 262 };
 263
 264 static void
 265 ia64_register_convert_to_virtual (int regnum, struct type *type,
 266                                   char *from, char *to)
 267 {
 268   if (regnum >= IA64_FR0_REGNUM && regnum <= IA64_FR127_REGNUM)
 269     {
 270       DOUBLEST val;
 271       floatformat_to_doublest (&floatformat_ia64_ext, from, &val);
 272       deprecated_store_floating (to, TYPE_LENGTH(type), val);
 273     }
 274   else
 275     error("ia64_register_convert_to_virtual called with non floating point register number");
 276 }
 277
 278 static void
 279 ia64_register_convert_to_raw (struct type *type, int regnum,
 280                               const char *from, char *to)
 281 {
 282   if (regnum >= IA64_FR0_REGNUM && regnum <= IA64_FR127_REGNUM)
 283     {
 284       DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type));
 285       floatformat_from_doublest (&floatformat_ia64_ext, &val, to);
 286     }
 287   else
 288     error("ia64_register_convert_to_raw called with non floating point register number");
 289 }
 290
 291 struct type *
 292 ia64_register_virtual_type (int reg)
 293 {
 294   if (reg >= IA64_FR0_REGNUM && reg <= IA64_FR127_REGNUM)
 295     return builtin_type_long_double;
 296   else
 297     return builtin_type_long;
 298 }
 299
 300 static int
 301 ia64_register_byte (int reg)
 302 {
 303   return (8 * reg) +
 304    (reg <= IA64_FR0_REGNUM ? 0 : 8 * ((reg > IA64_FR127_REGNUM) ? 128 : reg - IA64_FR0_REGNUM));
 305 }
 306
 307 /* Read the given register from a sigcontext structure in the
 308    specified frame.  */
 309
 310 static CORE_ADDR
 311 read_sigcontext_register (struct frame_info *frame, int regnum)
 312 {
 313   CORE_ADDR regaddr;
 314
 315   if (frame == NULL)
 316     internal_error (__FILE__, __LINE__,
 317                     "read_sigcontext_register: NULL frame");
 318   if (!(get_frame_type (frame) == SIGTRAMP_FRAME))
 319     internal_error (__FILE__, __LINE__,
 320                     "read_sigcontext_register: frame not a signal trampoline");
 321   if (SIGCONTEXT_REGISTER_ADDRESS == 0)
 322     internal_error (__FILE__, __LINE__,
 323                     "read_sigcontext_register: SIGCONTEXT_REGISTER_ADDRESS is 0");
 324
 325   regaddr = SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regnum);
 326   if (regaddr)
 327     return read_memory_integer (regaddr, REGISTER_RAW_SIZE (regnum));
 328   else
 329     internal_error (__FILE__, __LINE__,
 330                     "read_sigcontext_register: Register %d not in struct sigcontext", regnum);
 331 }
 332
 333 /* Extract ``len'' bits from an instruction bundle starting at
 334    bit ``from''.  */
 335
 336 static long long
 337 extract_bit_field (char *bundle, int from, int len)
 338 {
 339   long long result = 0LL;
 340   int to = from + len;
 341   int from_byte = from / 8;
 342   int to_byte = to / 8;
 343   unsigned char *b = (unsigned char *) bundle;
 344   unsigned char c;
 345   int lshift;
 346   int i;
 347
 348   c = b[from_byte];
 349   if (from_byte == to_byte)
 350     c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
 351   result = c >> (from % 8);
 352   lshift = 8 - (from % 8);
 353
 354   for (i = from_byte+1; i < to_byte; i++)
 355     {
 356       result |= ((long long) b[i]) << lshift;
 357       lshift += 8;
 358     }
 359
 360   if (from_byte < to_byte && (to % 8 != 0))
 361     {
 362       c = b[to_byte];
 363       c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
 364       result |= ((long long) c) << lshift;
 365     }
 366
 367   return result;
 368 }
 369
 370 /* Replace the specified bits in an instruction bundle */
 371
 372 static void
 373 replace_bit_field (char *bundle, long long val, int from, int len)
 374 {
 375   int to = from + len;
 376   int from_byte = from / 8;
 377   int to_byte = to / 8;
 378   unsigned char *b = (unsigned char *) bundle;
 379   unsigned char c;
 380
 381   if (from_byte == to_byte)
 382     {
 383       unsigned char left, right;
 384       c = b[from_byte];
 385       left = (c >> (to % 8)) << (to % 8);
 386       right = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
 387       c = (unsigned char) (val & 0xff);
 388       c = (unsigned char) (c << (from % 8 + 8 - to % 8)) >> (8 - to % 8);
 389       c |= right | left;
 390       b[from_byte] = c;
 391     }
 392   else
 393     {
 394       int i;
 395       c = b[from_byte];
 396       c = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
 397       c = c | (val << (from % 8));
 398       b[from_byte] = c;
 399       val >>= 8 - from % 8;
 400
 401       for (i = from_byte+1; i < to_byte; i++)
 402         {
 403           c = val & 0xff;
 404           val >>= 8;
 405           b[i] = c;
 406         }
 407
 408       if (to % 8 != 0)
 409         {
 410           unsigned char cv = (unsigned char) val;
 411           c = b[to_byte];
 412           c = c >> (to % 8) << (to % 8);
 413           c |= ((unsigned char) (cv << (8 - to % 8))) >> (8 - to % 8);
 414           b[to_byte] = c;
 415         }
 416     }
 417 }
 418
 419 /* Return the contents of slot N (for N = 0, 1, or 2) in
 420    and instruction bundle */
 421
 422 static long long
 423 slotN_contents (char *bundle, int slotnum)
 424 {
 425   return extract_bit_field (bundle, 5+41*slotnum, 41);
 426 }
 427
 428 /* Store an instruction in an instruction bundle */
 429
 430 static void
 431 replace_slotN_contents (char *bundle, long long instr, int slotnum)
 432 {
 433   replace_bit_field (bundle, instr, 5+41*slotnum, 41);
 434 }
 435
 436 static enum instruction_type template_encoding_table[32][3] =
 437 {
 438   { M, I, I },                          /* 00 */
 439   { M, I, I },                          /* 01 */
 440   { M, I, I },                          /* 02 */
 441   { M, I, I },                          /* 03 */
 442   { M, L, X },                          /* 04 */
 443   { M, L, X },                          /* 05 */
 444   { undefined, undefined, undefined },  /* 06 */
 445   { undefined, undefined, undefined },  /* 07 */
 446   { M, M, I },                          /* 08 */
 447   { M, M, I },                          /* 09 */
 448   { M, M, I },                          /* 0A */
 449   { M, M, I },                          /* 0B */
 450   { M, F, I },                          /* 0C */
 451   { M, F, I },                          /* 0D */
 452   { M, M, F },                          /* 0E */
 453   { M, M, F },                          /* 0F */
 454   { M, I, B },                          /* 10 */
 455   { M, I, B },                          /* 11 */
 456   { M, B, B },                          /* 12 */
 457   { M, B, B },                          /* 13 */
 458   { undefined, undefined, undefined },  /* 14 */
 459   { undefined, undefined, undefined },  /* 15 */
 460   { B, B, B },                          /* 16 */
 461   { B, B, B },                          /* 17 */
 462   { M, M, B },                          /* 18 */
 463   { M, M, B },                          /* 19 */
 464   { undefined, undefined, undefined },  /* 1A */
 465   { undefined, undefined, undefined },  /* 1B */
 466   { M, F, B },                          /* 1C */
 467   { M, F, B },                          /* 1D */
 468   { undefined, undefined, undefined },  /* 1E */
 469   { undefined, undefined, undefined },  /* 1F */
 470 };
 471
 472 /* Fetch and (partially) decode an instruction at ADDR and return the
 473    address of the next instruction to fetch.  */
 474
 475 static CORE_ADDR
 476 fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr)
 477 {
 478   char bundle[BUNDLE_LEN];
 479   int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
 480   long long template;
 481   int val;
 482
 483   /* Warn about slot numbers greater than 2.  We used to generate
 484      an error here on the assumption that the user entered an invalid
 485      address.  But, sometimes GDB itself requests an invalid address.
 486      This can (easily) happen when execution stops in a function for
 487      which there are no symbols.  The prologue scanner will attempt to
 488      find the beginning of the function - if the nearest symbol
 489      happens to not be aligned on a bundle boundary (16 bytes), the
 490      resulting starting address will cause GDB to think that the slot
 491      number is too large.
 492
 493      So we warn about it and set the slot number to zero.  It is
 494      not necessarily a fatal condition, particularly if debugging
 495      at the assembly language level.  */
 496   if (slotnum > 2)
 497     {
 498       warning ("Can't fetch instructions for slot numbers greater than 2.\n"
 499                "Using slot 0 instead");
 500       slotnum = 0;
 501     }
 502
 503   addr &= ~0x0f;
 504
 505   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 506
 507   if (val != 0)
 508     return 0;
 509
 510   *instr = slotN_contents (bundle, slotnum);
 511   template = extract_bit_field (bundle, 0, 5);
 512   *it = template_encoding_table[(int)template][slotnum];
 513
 514   if (slotnum == 2 || (slotnum == 1 && *it == L))
 515     addr += 16;
 516   else
 517     addr += (slotnum + 1) * SLOT_MULTIPLIER;
 518
 519   return addr;
 520 }
 521
 522 /* There are 5 different break instructions (break.i, break.b,
 523    break.m, break.f, and break.x), but they all have the same
 524    encoding.  (The five bit template in the low five bits of the
 525    instruction bundle distinguishes one from another.)
 526
 527    The runtime architecture manual specifies that break instructions
 528    used for debugging purposes must have the upper two bits of the 21
 529    bit immediate set to a 0 and a 1 respectively.  A breakpoint
 530    instruction encodes the most significant bit of its 21 bit
 531    immediate at bit 36 of the 41 bit instruction.  The penultimate msb
 532    is at bit 25 which leads to the pattern below.
 533
 534    Originally, I had this set up to do, e.g, a "break.i 0x80000"  But
 535    it turns out that 0x80000 was used as the syscall break in the early
 536    simulators.  So I changed the pattern slightly to do "break.i 0x080001"
 537    instead.  But that didn't work either (I later found out that this
 538    pattern was used by the simulator that I was using.)  So I ended up
 539    using the pattern seen below. */
 540
 541 #if 0
 542 #define IA64_BREAKPOINT 0x00002000040LL
 543 #endif
 544 #define IA64_BREAKPOINT 0x00003333300LL
 545
 546 static int
 547 ia64_memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
 548 {
 549   char bundle[BUNDLE_LEN];
 550   int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
 551   long long instr;
 552   int val;
 553   int template;
 554
 555   if (slotnum > 2)
 556     error("Can't insert breakpoint for slot numbers greater than 2.");
 557
 558   addr &= ~0x0f;
 559
 560   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 561
 562   /* Check for L type instruction in 2nd slot, if present then
 563      bump up the slot number to the 3rd slot */
 564   template = extract_bit_field (bundle, 0, 5);
 565   if (slotnum == 1 && template_encoding_table[template][1] == L)
 566     {
 567       slotnum = 2;
 568     }
 569
 570   instr = slotN_contents (bundle, slotnum);
 571   memcpy(contents_cache, &instr, sizeof(instr));
 572   replace_slotN_contents (bundle, IA64_BREAKPOINT, slotnum);
 573   if (val == 0)
 574     target_write_memory (addr, bundle, BUNDLE_LEN);
 575
 576   return val;
 577 }
 578
 579 static int
 580 ia64_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 581 {
 582   char bundle[BUNDLE_LEN];
 583   int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER;
 584   long long instr;
 585   int val;
 586   int template;
 587
 588   addr &= ~0x0f;
 589
 590   val = target_read_memory (addr, bundle, BUNDLE_LEN);
 591
 592   /* Check for L type instruction in 2nd slot, if present then
 593      bump up the slot number to the 3rd slot */
 594   template = extract_bit_field (bundle, 0, 5);
 595   if (slotnum == 1 && template_encoding_table[template][1] == L)
 596     {
 597       slotnum = 2;
 598     }
 599
 600   memcpy (&instr, contents_cache, sizeof instr);
 601   replace_slotN_contents (bundle, instr, slotnum);
 602   if (val == 0)
 603     target_write_memory (addr, bundle, BUNDLE_LEN);
 604
 605   return val;
 606 }
 607
 608 /* We don't really want to use this, but remote.c needs to call it in order
 609    to figure out if Z-packets are supported or not.  Oh, well. */
 610 const unsigned char *
 611 ia64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 612 {
 613   static unsigned char breakpoint[] =
 614     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 615   *lenptr = sizeof (breakpoint);
 616 #if 0
 617   *pcptr &= ~0x0f;
 618 #endif
 619   return breakpoint;
 620 }
 621
 622 static CORE_ADDR
 623 ia64_read_fp (void)
 624 {
 625   /* We won't necessarily have a frame pointer and even if we do, it
 626      winds up being extraordinarly messy when attempting to find the
 627      frame chain.  So for the purposes of creating frames (which is
 628      all deprecated_read_fp() is used for), simply use the stack
 629      pointer value instead.  */
 630   gdb_assert (SP_REGNUM >= 0);
 631   return read_register (SP_REGNUM);
 632 }
 633
 634 static CORE_ADDR
 635 ia64_read_pc (ptid_t ptid)
 636 {
 637   CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
 638   CORE_ADDR pc_value   = read_register_pid (IA64_IP_REGNUM, ptid);
 639   int slot_num = (psr_value >> 41) & 3;
 640
 641   return pc_value | (slot_num * SLOT_MULTIPLIER);
 642 }
 643
 644 static void
 645 ia64_write_pc (CORE_ADDR new_pc, ptid_t ptid)
 646 {
 647   int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
 648   CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
 649   psr_value &= ~(3LL << 41);
 650   psr_value |= (CORE_ADDR)(slot_num & 0x3) << 41;
 651
 652   new_pc &= ~0xfLL;
 653
 654   write_register_pid (IA64_PSR_REGNUM, psr_value, ptid);
 655   write_register_pid (IA64_IP_REGNUM, new_pc, ptid);
 656 }
 657
 658 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
 659
 660 /* Returns the address of the slot that's NSLOTS slots away from
 661    the address ADDR. NSLOTS may be positive or negative. */
 662 static CORE_ADDR
 663 rse_address_add(CORE_ADDR addr, int nslots)
 664 {
 665   CORE_ADDR new_addr;
 666   int mandatory_nat_slots = nslots / 63;
 667   int direction = nslots < 0 ? -1 : 1;
 668
 669   new_addr = addr + 8 * (nslots + mandatory_nat_slots);
 670
 671   if ((new_addr >> 9)  != ((addr + 8 * 64 * mandatory_nat_slots) >> 9))
 672     new_addr += 8 * direction;
 673
 674   if (IS_NaT_COLLECTION_ADDR(new_addr))
 675     new_addr += 8 * direction;
 676
 677   return new_addr;
 678 }
 679
 680 /* The IA-64 frame chain is a bit odd.  We won't always have a frame
 681    pointer, so we use the SP value as the FP for the purpose of
 682    creating a frame.  There is sometimes a register (not fixed) which
 683    is used as a frame pointer.  When this register exists, it is not
 684    especially hard to determine which one is being used.  It isn't
 685    even really hard to compute the frame chain, but it can be
 686    computationally expensive.  So, instead of making life difficult
 687    (and slow), we pick a more convenient representation of the frame
 688    chain, knowing that we'll have to make some small adjustments in
 689    other places.  (E.g, note that deprecated_read_fp() is actually
 690    read_sp() in ia64_gdbarch_init() below.)
 691
 692    Okay, so what is the frame chain exactly?  It'll be the SP value
 693    at the time that the function in question was entered.
 694
 695    Note that this *should* actually the frame pointer for the current
 696    function!  But as I note above, if we were to attempt to find the
 697    address of the beginning of the previous frame, we'd waste a lot
 698    of cycles for no good reason.  So instead, we simply choose to
 699    represent the frame chain as the end of the previous frame instead
 700    of the beginning.  */
 701
 702 static CORE_ADDR
 703 ia64_frame_chain (struct frame_info *frame)
 704 {
 705   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
 706     return read_sigcontext_register (frame, sp_regnum);
 707   else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 708                                         get_frame_base (frame),
 709                                         get_frame_base (frame)))
 710     return get_frame_base (frame);
 711   else
 712     {
 713       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
 714       if (get_frame_saved_regs (frame)[IA64_VFP_REGNUM])
 715         return read_memory_integer (get_frame_saved_regs (frame)[IA64_VFP_REGNUM], 8);
 716       else
 717         return (get_frame_base (frame)
 718                 + get_frame_extra_info (frame)->mem_stack_frame_size);
 719     }
 720 }
 721
 722 static CORE_ADDR
 723 ia64_frame_saved_pc (struct frame_info *frame)
 724 {
 725   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
 726     return read_sigcontext_register (frame, pc_regnum);
 727   else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 728                                         get_frame_base (frame),
 729                                         get_frame_base (frame)))
 730     return deprecated_read_register_dummy (get_frame_pc (frame),
 731                                            get_frame_base (frame), pc_regnum);
 732   else
 733     {
 734       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
 735
 736       if (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM])
 737         return read_memory_integer (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM], 8);
 738       else if (get_next_frame (frame)
 739                && (get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME))
 740         return read_sigcontext_register (get_next_frame (frame), IA64_BR0_REGNUM);
 741       else      /* either frameless, or not far enough along in the prologue... */
 742         return ia64_saved_pc_after_call (frame);
 743     }
 744 }
 745
 746 /* Limit the number of skipped non-prologue instructions since examining
 747    of the prologue is expensive.  */
 748 static int max_skip_non_prologue_insns = 40;
 749
 750 /* Given PC representing the starting address of a function, and
 751    LIM_PC which is the (sloppy) limit to which to scan when looking
 752    for a prologue, attempt to further refine this limit by using
 753    the line data in the symbol table.  If successful, a better guess
 754    on where the prologue ends is returned, otherwise the previous
 755    value of lim_pc is returned.  TRUST_LIMIT is a pointer to a flag
 756    which will be set to indicate whether the returned limit may be
 757    used with no further scanning in the event that the function is
 758    frameless.  */
 759
 760 static CORE_ADDR
 761 refine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc, int *trust_limit)
 762 {
 763   struct symtab_and_line prologue_sal;
 764   CORE_ADDR start_pc = pc;
 765
 766   /* Start off not trusting the limit.  */
 767   *trust_limit = 0;
 768
 769   prologue_sal = find_pc_line (pc, 0);
 770   if (prologue_sal.line != 0)
 771     {
 772       int i;
 773       CORE_ADDR addr = prologue_sal.end;
 774
 775       /* Handle the case in which compiler's optimizer/scheduler
 776          has moved instructions into the prologue.  We scan ahead
 777          in the function looking for address ranges whose corresponding
 778          line number is less than or equal to the first one that we
 779          found for the function.  (It can be less than when the
 780          scheduler puts a body instruction before the first prologue
 781          instruction.)  */
 782       for (i = 2 * max_skip_non_prologue_insns;
 783            i > 0 && (lim_pc == 0 || addr < lim_pc);
 784            i--)
 785         {
 786           struct symtab_and_line sal;
 787
 788           sal = find_pc_line (addr, 0);
 789           if (sal.line == 0)
 790             break;
 791           if (sal.line <= prologue_sal.line
 792               && sal.symtab == prologue_sal.symtab)
 793             {
 794               prologue_sal = sal;
 795             }
 796           addr = sal.end;
 797         }
 798
 799       if (lim_pc == 0 || prologue_sal.end < lim_pc)
 800         {
 801           lim_pc = prologue_sal.end;
 802           if (start_pc == get_pc_function_start (lim_pc))
 803             *trust_limit = 1;
 804         }
 805     }
 806   return lim_pc;
 807 }
 808
 809 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
 810   || (8 <= (_regnum_) && (_regnum_) <= 11) \
 811   || (14 <= (_regnum_) && (_regnum_) <= 31))
 812 #define imm9(_instr_) \
 813   ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
 814    | (((_instr_) & 0x00008000000LL) >> 20) \
 815    | (((_instr_) & 0x00000001fc0LL) >> 6))
 816
 817 static CORE_ADDR
 818 examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
 819 {
 820   CORE_ADDR next_pc;
 821   CORE_ADDR last_prologue_pc = pc;
 822   instruction_type it;
 823   long long instr;
 824   int do_fsr_stuff = 0;
 825
 826   int cfm_reg  = 0;
 827   int ret_reg  = 0;
 828   int fp_reg   = 0;
 829   int unat_save_reg = 0;
 830   int pr_save_reg = 0;
 831   int mem_stack_frame_size = 0;
 832   int spill_reg   = 0;
 833   CORE_ADDR spill_addr = 0;
 834   char instores[8];
 835   char infpstores[8];
 836   char reg_contents[256];
 837   int trust_limit;
 838   int frameless = 0;
 839
 840   memset (instores, 0, sizeof instores);
 841   memset (infpstores, 0, sizeof infpstores);
 842   memset (reg_contents, 0, sizeof reg_contents);
 843
 844   if (frame && !get_frame_saved_regs (frame))
 845     {
 846       frame_saved_regs_zalloc (frame);
 847       do_fsr_stuff = 1;
 848     }
 849
 850   if (frame
 851       && !do_fsr_stuff
 852       && get_frame_extra_info (frame)->after_prologue != 0
 853       && get_frame_extra_info (frame)->after_prologue <= lim_pc)
 854     return get_frame_extra_info (frame)->after_prologue;
 855
 856   lim_pc = refine_prologue_limit (pc, lim_pc, &trust_limit);
 857   next_pc = fetch_instruction (pc, &it, &instr);
 858
 859   /* We want to check if we have a recognizable function start before we
 860      look ahead for a prologue.  */
 861   if (pc < lim_pc && next_pc
 862       && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL))
 863     {
 864       /* alloc - start of a regular function.  */
 865       int sor = (int) ((instr & 0x00078000000LL) >> 27);
 866       int sol = (int) ((instr & 0x00007f00000LL) >> 20);
 867       int sof = (int) ((instr & 0x000000fe000LL) >> 13);
 868       /* Okay, so sor, sol, and sof aren't used right now; but perhaps
 869          we could compare against the size given to us via the cfm as
 870          either a sanity check or possibly to see if the frame has been
 871          changed by a later alloc instruction... */
 872       int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 873       cfm_reg = rN;
 874       last_prologue_pc = next_pc;
 875       pc = next_pc;
 876     }
 877   else
 878     {
 879       /* Look for a leaf routine.  */
 880       if (pc < lim_pc && next_pc
 881           && (it == I || it == M)
 882           && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
 883         {
 884           /* adds rN = imm14, rM   (or mov rN, rM  when imm14 is 0) */
 885           int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
 886                            | ((instr & 0x001f8000000LL) >> 20)
 887                            | ((instr & 0x000000fe000LL) >> 13));
 888           int rM = (int) ((instr & 0x00007f00000LL) >> 20);
 889           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 890           int qp = (int) (instr & 0x0000000003fLL);
 891           if (qp == 0 && rN == 2 && imm == 0 && rM == 12 && fp_reg == 0)
 892             {
 893               /* mov r2, r12 - beginning of leaf routine */
 894               fp_reg = rN;
 895               frameless = 1;
 896               last_prologue_pc = next_pc;
 897             }
 898         }
 899
 900       /* If we don't recognize a regular function or leaf routine, we are
 901          done.  */
 902       if (!fp_reg)
 903         {
 904           pc = lim_pc;
 905           if (trust_limit)
 906             last_prologue_pc = lim_pc;
 907         }
 908     }
 909
 910   /* Loop, looking for prologue instructions, keeping track of
 911      where preserved registers were spilled. */
 912   while (pc < lim_pc)
 913     {
 914       next_pc = fetch_instruction (pc, &it, &instr);
 915       if (next_pc == 0)
 916         break;
 917
 918       if ((it == B && ((instr & 0x1e1f800003f) != 0x04000000000))
 919           || ((instr & 0x3fLL) != 0LL))
 920         {
 921           /* Exit loop upon hitting a non-nop branch instruction
 922              or a predicated instruction. */
 923           if (trust_limit)
 924             lim_pc = pc;
 925           break;
 926         }
 927       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00188000000LL))
 928         {
 929           /* Move from BR */
 930           int b2 = (int) ((instr & 0x0000000e000LL) >> 13);
 931           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 932           int qp = (int) (instr & 0x0000000003f);
 933
 934           if (qp == 0 && b2 == 0 && rN >= 32 && ret_reg == 0)
 935             {
 936               ret_reg = rN;
 937               last_prologue_pc = next_pc;
 938             }
 939         }
 940       else if ((it == I || it == M)
 941           && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
 942         {
 943           /* adds rN = imm14, rM   (or mov rN, rM  when imm14 is 0) */
 944           int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
 945                            | ((instr & 0x001f8000000LL) >> 20)
 946                            | ((instr & 0x000000fe000LL) >> 13));
 947           int rM = (int) ((instr & 0x00007f00000LL) >> 20);
 948           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 949           int qp = (int) (instr & 0x0000000003fLL);
 950
 951           if (qp == 0 && rN >= 32 && imm == 0 && rM == 12 && fp_reg == 0)
 952             {
 953               /* mov rN, r12 */
 954               fp_reg = rN;
 955               last_prologue_pc = next_pc;
 956             }
 957           else if (qp == 0 && rN == 12 && rM == 12)
 958             {
 959               /* adds r12, -mem_stack_frame_size, r12 */
 960               mem_stack_frame_size -= imm;
 961               last_prologue_pc = next_pc;
 962             }
 963           else if (qp == 0 && rN == 2
 964                 && ((rM == fp_reg && fp_reg != 0) || rM == 12))
 965             {
 966               /* adds r2, spilloffset, rFramePointer
 967                    or
 968                  adds r2, spilloffset, r12
 969
 970                  Get ready for stf.spill or st8.spill instructions.
 971                  The address to start spilling at is loaded into r2.
 972                  FIXME:  Why r2?  That's what gcc currently uses; it
 973                  could well be different for other compilers.  */
 974
 975               /* Hmm... whether or not this will work will depend on
 976                  where the pc is.  If it's still early in the prologue
 977                  this'll be wrong.  FIXME */
 978               spill_addr  = (frame ? get_frame_base (frame) : 0)
 979                           + (rM == 12 ? 0 : mem_stack_frame_size)
 980                           + imm;
 981               spill_reg   = rN;
 982               last_prologue_pc = next_pc;
 983             }
 984           else if (qp == 0 && rM >= 32 && rM < 40 && !instores[rM] &&
 985                    rN < 256 && imm == 0)
 986             {
 987               /* mov rN, rM where rM is an input register */
 988               reg_contents[rN] = rM;
 989               last_prologue_pc = next_pc;
 990             }
 991           else if (frameless && qp == 0 && rN == fp_reg && imm == 0 &&
 992                    rM == 2)
 993             {
 994               /* mov r12, r2 */
 995               last_prologue_pc = next_pc;
 996               break;
 997             }
 998         }
 999       else if (it == M
1000             && (   ((instr & 0x1efc0000000LL) == 0x0eec0000000LL)
1001                 || ((instr & 0x1ffc8000000LL) == 0x0cec0000000LL) ))
1002         {
1003           /* stf.spill [rN] = fM, imm9
1004              or
1005              stf.spill [rN] = fM  */
1006
1007           int imm = imm9(instr);
1008           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1009           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
1010           int qp = (int) (instr & 0x0000000003fLL);
1011           if (qp == 0 && rN == spill_reg && spill_addr != 0
1012               && ((2 <= fM && fM <= 5) || (16 <= fM && fM <= 31)))
1013             {
1014               if (do_fsr_stuff)
1015                 get_frame_saved_regs (frame)[IA64_FR0_REGNUM + fM] = spill_addr;
1016
1017               if ((instr & 0x1efc0000000) == 0x0eec0000000)
1018                 spill_addr += imm;
1019               else
1020                 spill_addr = 0;         /* last one; must be done */
1021               last_prologue_pc = next_pc;
1022             }
1023         }
1024       else if ((it == M && ((instr & 0x1eff8000000LL) == 0x02110000000LL))
1025             || (it == I && ((instr & 0x1eff8000000LL) == 0x00050000000LL)) )
1026         {
1027           /* mov.m rN = arM
1028                or
1029              mov.i rN = arM */
1030
1031           int arM = (int) ((instr & 0x00007f00000LL) >> 20);
1032           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
1033           int qp  = (int) (instr & 0x0000000003fLL);
1034           if (qp == 0 && isScratch (rN) && arM == 36 /* ar.unat */)
1035             {
1036               /* We have something like "mov.m r3 = ar.unat".  Remember the
1037                  r3 (or whatever) and watch for a store of this register... */
1038               unat_save_reg = rN;
1039               last_prologue_pc = next_pc;
1040             }
1041         }
1042       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00198000000LL))
1043         {
1044           /* mov rN = pr */
1045           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
1046           int qp  = (int) (instr & 0x0000000003fLL);
1047           if (qp == 0 && isScratch (rN))
1048             {
1049               pr_save_reg = rN;
1050               last_prologue_pc = next_pc;
1051             }
1052         }
1053       else if (it == M
1054             && (   ((instr & 0x1ffc8000000LL) == 0x08cc0000000LL)
1055                 || ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)))
1056         {
1057           /* st8 [rN] = rM
1058               or
1059              st8 [rN] = rM, imm9 */
1060           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1061           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1062           int qp = (int) (instr & 0x0000000003fLL);
1063           int indirect = rM < 256 ? reg_contents[rM] : 0;
1064           if (qp == 0 && rN == spill_reg && spill_addr != 0
1065               && (rM == unat_save_reg || rM == pr_save_reg))
1066             {
1067               /* We've found a spill of either the UNAT register or the PR
1068                  register.  (Well, not exactly; what we've actually found is
1069                  a spill of the register that UNAT or PR was moved to).
1070                  Record that fact and move on... */
1071               if (rM == unat_save_reg)
1072                 {
1073                   /* Track UNAT register */
1074                   if (do_fsr_stuff)
1075                     get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] = spill_addr;
1076                   unat_save_reg = 0;
1077                 }
1078               else
1079                 {
1080                   /* Track PR register */
1081                   if (do_fsr_stuff)
1082                     get_frame_saved_regs (frame)[IA64_PR_REGNUM] = spill_addr;
1083                   pr_save_reg = 0;
1084                 }
1085               if ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)
1086                 /* st8 [rN] = rM, imm9 */
1087                 spill_addr += imm9(instr);
1088               else
1089                 spill_addr = 0;         /* must be done spilling */
1090               last_prologue_pc = next_pc;
1091             }
1092           else if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1093             {
1094               /* Allow up to one store of each input register. */
1095               instores[rM-32] = 1;
1096               last_prologue_pc = next_pc;
1097             }
1098           else if (qp == 0 && 32 <= indirect && indirect < 40 &&
1099                    !instores[indirect-32])
1100             {
1101               /* Allow an indirect store of an input register.  */
1102               instores[indirect-32] = 1;
1103               last_prologue_pc = next_pc;
1104             }
1105         }
1106       else if (it == M && ((instr & 0x1ff08000000LL) == 0x08c00000000LL))
1107         {
1108           /* One of
1109                st1 [rN] = rM
1110                st2 [rN] = rM
1111                st4 [rN] = rM
1112                st8 [rN] = rM
1113              Note that the st8 case is handled in the clause above.
1114
1115              Advance over stores of input registers. One store per input
1116              register is permitted. */
1117           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1118           int qp = (int) (instr & 0x0000000003fLL);
1119           int indirect = rM < 256 ? reg_contents[rM] : 0;
1120           if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1121             {
1122               instores[rM-32] = 1;
1123               last_prologue_pc = next_pc;
1124             }
1125           else if (qp == 0 && 32 <= indirect && indirect < 40 &&
1126                    !instores[indirect-32])
1127             {
1128               /* Allow an indirect store of an input register.  */
1129               instores[indirect-32] = 1;
1130               last_prologue_pc = next_pc;
1131             }
1132         }
1133       else if (it == M && ((instr & 0x1ff88000000LL) == 0x0cc80000000LL))
1134         {
1135           /* Either
1136                stfs [rN] = fM
1137              or
1138                stfd [rN] = fM
1139
1140              Advance over stores of floating point input registers.  Again
1141              one store per register is permitted */
1142           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
1143           int qp = (int) (instr & 0x0000000003fLL);
1144           if (qp == 0 && 8 <= fM && fM < 16 && !infpstores[fM - 8])
1145             {
1146               infpstores[fM-8] = 1;
1147               last_prologue_pc = next_pc;
1148             }
1149         }
1150       else if (it == M
1151             && (   ((instr & 0x1ffc8000000LL) == 0x08ec0000000LL)
1152                 || ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)))
1153         {
1154           /* st8.spill [rN] = rM
1155                or
1156              st8.spill [rN] = rM, imm9 */
1157           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1158           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1159           int qp = (int) (instr & 0x0000000003fLL);
1160           if (qp == 0 && rN == spill_reg && 4 <= rM && rM <= 7)
1161             {
1162               /* We've found a spill of one of the preserved general purpose
1163                  regs.  Record the spill address and advance the spill
1164                  register if appropriate. */
1165               if (do_fsr_stuff)
1166                 get_frame_saved_regs (frame)[IA64_GR0_REGNUM + rM] = spill_addr;
1167               if ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)
1168                 /* st8.spill [rN] = rM, imm9 */
1169                 spill_addr += imm9(instr);
1170               else
1171                 spill_addr = 0;         /* Done spilling */
1172               last_prologue_pc = next_pc;
1173             }
1174         }
1175
1176       pc = next_pc;
1177     }
1178
1179   if (do_fsr_stuff) {
1180     int i;
1181     CORE_ADDR addr;
1182     int sor, rrb_gr;
1183
1184     /* Extract the size of the rotating portion of the stack
1185        frame and the register rename base from the current
1186        frame marker. */
1187     sor = ((get_frame_extra_info (frame)->cfm >> 14) & 0xf) * 8;
1188     rrb_gr = (get_frame_extra_info (frame)->cfm >> 18) & 0x7f;
1189
1190     for (i = 0, addr = get_frame_extra_info (frame)->bsp;
1191          i < get_frame_extra_info (frame)->sof;
1192          i++, addr += 8)
1193       {
1194         if (IS_NaT_COLLECTION_ADDR (addr))
1195           {
1196             addr += 8;
1197           }
1198         if (i < sor)
1199           get_frame_saved_regs (frame)[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
1200             = addr;
1201         else
1202           get_frame_saved_regs (frame)[IA64_GR32_REGNUM + i] = addr;
1203
1204         if (i+32 == cfm_reg)
1205           get_frame_saved_regs (frame)[IA64_CFM_REGNUM] = addr;
1206         if (i+32 == ret_reg)
1207           get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] = addr;
1208         if (i+32 == fp_reg)
1209           get_frame_saved_regs (frame)[IA64_VFP_REGNUM] = addr;
1210       }
1211   }
1212
1213   if (frame && get_frame_extra_info (frame))
1214     {
1215       get_frame_extra_info (frame)->after_prologue = last_prologue_pc;
1216       get_frame_extra_info (frame)->mem_stack_frame_size = mem_stack_frame_size;
1217       get_frame_extra_info (frame)->fp_reg = fp_reg;
1218     }
1219
1220   /* Try and trust the lim_pc value whenever possible.  */
1221   if (trust_limit && lim_pc >= last_prologue_pc)
1222     return lim_pc;
1223
1224   return last_prologue_pc;
1225 }
1226
1227 CORE_ADDR
1228 ia64_skip_prologue (CORE_ADDR pc)
1229 {
1230   return examine_prologue (pc, pc+1024, 0);
1231 }
1232
1233 static void
1234 ia64_frame_init_saved_regs (struct frame_info *frame)
1235 {
1236   if (get_frame_saved_regs (frame))
1237     return;
1238
1239   if ((get_frame_type (frame) == SIGTRAMP_FRAME) && SIGCONTEXT_REGISTER_ADDRESS)
1240     {
1241       int regno;
1242
1243       frame_saved_regs_zalloc (frame);
1244
1245       get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] =
1246         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_IP_REGNUM);
1247       get_frame_saved_regs (frame)[IA64_CFM_REGNUM] =
1248         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_CFM_REGNUM);
1249       get_frame_saved_regs (frame)[IA64_PSR_REGNUM] =
1250         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_PSR_REGNUM);
1251 #if 0
1252       get_frame_saved_regs (frame)[IA64_BSP_REGNUM] =
1253         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_BSP_REGNUM);
1254 #endif
1255       get_frame_saved_regs (frame)[IA64_RNAT_REGNUM] =
1256         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_RNAT_REGNUM);
1257       get_frame_saved_regs (frame)[IA64_CCV_REGNUM] =
1258         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_CCV_REGNUM);
1259       get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] =
1260         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_UNAT_REGNUM);
1261       get_frame_saved_regs (frame)[IA64_FPSR_REGNUM] =
1262         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_FPSR_REGNUM);
1263       get_frame_saved_regs (frame)[IA64_PFS_REGNUM] =
1264         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_PFS_REGNUM);
1265       get_frame_saved_regs (frame)[IA64_LC_REGNUM] =
1266         SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_LC_REGNUM);
1267       for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
1268         if (regno != sp_regnum)
1269           get_frame_saved_regs (frame)[regno] =
1270             SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regno);
1271       for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1272         get_frame_saved_regs (frame)[regno] =
1273           SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regno);
1274       for (regno = IA64_FR2_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1275         get_frame_saved_regs (frame)[regno] =
1276           SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regno);
1277     }
1278   else
1279     {
1280       CORE_ADDR func_start;
1281
1282       func_start = get_frame_func (frame);
1283       examine_prologue (func_start, get_frame_pc (frame), frame);
1284     }
1285 }
1286
1287 static void
1288 ia64_get_saved_register (char *raw_buffer,
1289                          int *optimized,
1290                          CORE_ADDR *addrp,
1291                          struct frame_info *frame,
1292                          int regnum,
1293                          enum lval_type *lval)
1294 {
1295   int is_dummy_frame;
1296
1297   if (!target_has_registers)
1298     error ("No registers.");
1299
1300   if (optimized != NULL)
1301     *optimized = 0;
1302
1303   if (addrp != NULL)
1304     *addrp = 0;
1305
1306   if (lval != NULL)
1307     *lval = not_lval;
1308
1309   is_dummy_frame = DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
1310                                                 get_frame_base (frame),
1311                                                 get_frame_base (frame));
1312
1313   if (regnum == SP_REGNUM && get_next_frame (frame))
1314     {
1315       /* Handle SP values for all frames but the topmost. */
1316       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
1317                               get_frame_base (frame));
1318     }
1319   else if (regnum == IA64_BSP_REGNUM)
1320     {
1321       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
1322                               get_frame_extra_info (frame)->bsp);
1323     }
1324   else if (regnum == IA64_VFP_REGNUM)
1325     {
1326       /* If the function in question uses an automatic register (r32-r127)
1327          for the frame pointer, it'll be found by ia64_find_saved_register()
1328          above.  If the function lacks one of these frame pointers, we can
1329          still provide a value since we know the size of the frame */
1330       CORE_ADDR vfp = (get_frame_base (frame)
1331                        + get_frame_extra_info (frame)->mem_stack_frame_size);
1332       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
1333     }
1334   else if (IA64_PR0_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1335     {
1336       char pr_raw_buffer[MAX_REGISTER_SIZE];
1337       int  pr_optim;
1338       enum lval_type pr_lval;
1339       CORE_ADDR pr_addr;
1340       int prN_val;
1341       ia64_get_saved_register (pr_raw_buffer, &pr_optim, &pr_addr,
1342                                frame, IA64_PR_REGNUM, &pr_lval);
1343       if (IA64_PR16_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1344         {
1345           /* Fetch predicate register rename base from current frame
1346              marker for this frame. */
1347           int rrb_pr = (get_frame_extra_info (frame)->cfm >> 32) & 0x3f;
1348
1349           /* Adjust the register number to account for register rotation. */
1350           regnum = IA64_PR16_REGNUM
1351                  + ((regnum - IA64_PR16_REGNUM) + rrb_pr) % 48;
1352         }
1353       prN_val = extract_bit_field ((unsigned char *) pr_raw_buffer,
1354                                    regnum - IA64_PR0_REGNUM, 1);
1355       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), prN_val);
1356     }
1357   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
1358     {
1359       char unat_raw_buffer[MAX_REGISTER_SIZE];
1360       int  unat_optim;
1361       enum lval_type unat_lval;
1362       CORE_ADDR unat_addr;
1363       int unatN_val;
1364       ia64_get_saved_register (unat_raw_buffer, &unat_optim, &unat_addr,
1365                                frame, IA64_UNAT_REGNUM, &unat_lval);
1366       unatN_val = extract_bit_field ((unsigned char *) unat_raw_buffer,
1367                                    regnum - IA64_NAT0_REGNUM, 1);
1368       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
1369                               unatN_val);
1370     }
1371   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
1372     {
1373       int natval = 0;
1374       /* Find address of general register corresponding to nat bit we're
1375          interested in. */
1376       CORE_ADDR gr_addr = 0;
1377
1378       if (!is_dummy_frame)
1379         {
1380           DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
1381           gr_addr = get_frame_saved_regs (frame)[ regnum - IA64_NAT0_REGNUM
1382                                                 + IA64_GR0_REGNUM];
1383         }
1384       if (gr_addr)
1385         {
1386           /* Compute address of nat collection bits */
1387           CORE_ADDR nat_addr = gr_addr | 0x1f8;
1388           CORE_ADDR bsp = read_register (IA64_BSP_REGNUM);
1389           CORE_ADDR nat_collection;
1390           int nat_bit;
1391           /* If our nat collection address is bigger than bsp, we have to get
1392              the nat collection from rnat.  Otherwise, we fetch the nat
1393              collection from the computed address. */
1394           if (nat_addr >= bsp)
1395             nat_collection = read_register (IA64_RNAT_REGNUM);
1396           else
1397             nat_collection = read_memory_integer (nat_addr, 8);
1398           nat_bit = (gr_addr >> 3) & 0x3f;
1399           natval = (nat_collection >> nat_bit) & 1;
1400         }
1401       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), natval);
1402     }
1403   else if (regnum == IA64_IP_REGNUM)
1404     {
1405       CORE_ADDR pc;
1406       if (get_next_frame (frame))
1407         {
1408           /* FIXME: Set *addrp, *lval when possible. */
1409           pc = ia64_frame_saved_pc (get_next_frame (frame));
1410         }
1411       else
1412         {
1413           pc = read_pc ();
1414         }
1415       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (IA64_IP_REGNUM), pc);
1416     }
1417   else if (IA64_GR32_REGNUM <= regnum && regnum <= IA64_GR127_REGNUM)
1418     {
1419       CORE_ADDR addr = 0;
1420       if (!is_dummy_frame)
1421         {
1422           DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
1423           addr = get_frame_saved_regs (frame)[regnum];
1424         }
1425
1426       if (addr != 0)
1427         {
1428           if (lval != NULL)
1429             *lval = lval_memory;
1430           if (addrp != NULL)
1431             *addrp = addr;
1432           read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
1433         }
1434       else
1435         {
1436           /* r32 - r127 must be fetchable via memory.  If they aren't,
1437              then the register is unavailable */
1438           memset (raw_buffer, 0, REGISTER_RAW_SIZE (regnum));
1439         }
1440     }
1441   else
1442     {
1443       if (IA64_FR32_REGNUM <= regnum && regnum <= IA64_FR127_REGNUM)
1444         {
1445           /* Fetch floating point register rename base from current
1446              frame marker for this frame. */
1447           int rrb_fr = (get_frame_extra_info (frame)->cfm >> 25) & 0x7f;
1448
1449           /* Adjust the floating point register number to account for
1450              register rotation. */
1451           regnum = IA64_FR32_REGNUM
1452                  + ((regnum - IA64_FR32_REGNUM) + rrb_fr) % 96;
1453         }
1454
1455       deprecated_generic_get_saved_register (raw_buffer, optimized, addrp,
1456                                              frame, regnum, lval);
1457     }
1458 }
1459
1460 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1461    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1462    and TYPE is the type (which is known to be struct, union or array).  */
1463 int
1464 ia64_use_struct_convention (int gcc_p, struct type *type)
1465 {
1466   struct type *float_elt_type;
1467
1468   /* HFAs are structures (or arrays) consisting entirely of floating
1469      point values of the same length.  Up to 8 of these are returned
1470      in registers.  Don't use the struct convention when this is the
1471      case. */
1472   float_elt_type = is_float_or_hfa_type (type);
1473   if (float_elt_type != NULL
1474       && TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type) <= 8)
1475     return 0;
1476
1477   /* Other structs of length 32 or less are returned in r8-r11.
1478      Don't use the struct convention for those either. */
1479   return TYPE_LENGTH (type) > 32;
1480 }
1481
1482 void
1483 ia64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1484 {
1485   struct type *float_elt_type;
1486
1487   float_elt_type = is_float_or_hfa_type (type);
1488   if (float_elt_type != NULL)
1489     {
1490       int offset = 0;
1491       int regnum = IA64_FR8_REGNUM;
1492       int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
1493
1494       while (n-- > 0)
1495         {
1496           ia64_register_convert_to_virtual (regnum, float_elt_type,
1497             &regbuf[REGISTER_BYTE (regnum)], valbuf + offset);
1498           offset += TYPE_LENGTH (float_elt_type);
1499           regnum++;
1500         }
1501     }
1502   else
1503     memcpy (valbuf, &regbuf[REGISTER_BYTE (IA64_GR8_REGNUM)],
1504             TYPE_LENGTH (type));
1505 }
1506
1507 /* FIXME: Turn this into a stack of some sort.  Unfortunately, something
1508    like this is necessary though since the IA-64 calling conventions specify
1509    that r8 is not preserved. */
1510 static CORE_ADDR struct_return_address;
1511
1512 CORE_ADDR
1513 ia64_extract_struct_value_address (char *regbuf)
1514 {
1515   /* FIXME: See above. */
1516   return struct_return_address;
1517 }
1518
1519 static void
1520 ia64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1521 {
1522   /* FIXME: See above. */
1523   /* Note that most of the work was done in ia64_push_arguments() */
1524   struct_return_address = addr;
1525 }
1526
1527 int
1528 ia64_frameless_function_invocation (struct frame_info *frame)
1529 {
1530   DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
1531   return (get_frame_extra_info (frame)->mem_stack_frame_size == 0);
1532 }
1533
1534 CORE_ADDR
1535 ia64_saved_pc_after_call (struct frame_info *frame)
1536 {
1537   return read_register (IA64_BR0_REGNUM);
1538 }
1539
1540 static CORE_ADDR
1541 ia64_frame_args_address (struct frame_info *frame)
1542 {
1543   /* frame->frame points at the SP for this frame; But we want the start
1544      of the frame, not the end.  Calling frame chain will get his for us. */
1545   return ia64_frame_chain (frame);
1546 }
1547
1548 static CORE_ADDR
1549 ia64_frame_locals_address (struct frame_info *frame)
1550 {
1551   /* frame->frame points at the SP for this frame; But we want the start
1552      of the frame, not the end.  Calling frame chain will get his for us. */
1553   return ia64_frame_chain (frame);
1554 }
1555
1556 static void
1557 ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
1558 {
1559   CORE_ADDR bsp, cfm;
1560   int next_frame_is_call_dummy = ((get_next_frame (frame) != NULL)
1561     && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frame)),
1562                                     get_frame_base (get_next_frame (frame)),
1563                                     get_frame_base (get_next_frame (frame))));
1564
1565   frame_extra_info_zalloc (frame, sizeof (struct frame_extra_info));
1566
1567   if (get_next_frame (frame) == 0)
1568     {
1569       bsp = read_register (IA64_BSP_REGNUM);
1570       cfm = read_register (IA64_CFM_REGNUM);
1571
1572     }
1573   else if ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME))
1574     {
1575       bsp = read_sigcontext_register (get_next_frame (frame), IA64_BSP_REGNUM);
1576       cfm = read_sigcontext_register (get_next_frame (frame), IA64_CFM_REGNUM);
1577     }
1578   else if (next_frame_is_call_dummy)
1579     {
1580       bsp = deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame)),
1581                                             get_frame_base (get_next_frame (frame)),
1582                                             IA64_BSP_REGNUM);
1583       cfm = deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame)),
1584                                             get_frame_base (get_next_frame (frame)),
1585                                             IA64_CFM_REGNUM);
1586     }
1587   else
1588     {
1589       struct frame_info *frn = get_next_frame (frame);
1590
1591       DEPRECATED_FRAME_INIT_SAVED_REGS (frn);
1592
1593       if (get_frame_saved_regs (frn)[IA64_CFM_REGNUM] != 0)
1594         cfm = read_memory_integer (get_frame_saved_regs (frn)[IA64_CFM_REGNUM], 8);
1595       else if (get_next_frame (frn) && (get_frame_type (get_next_frame (frn)) == SIGTRAMP_FRAME))
1596         cfm = read_sigcontext_register (get_next_frame (frn), IA64_PFS_REGNUM);
1597       else if (get_next_frame (frn)
1598                && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frn)),
1599                                                get_frame_base (get_next_frame (frn)),
1600                                                get_frame_base (get_next_frame (frn))))
1601         cfm = deprecated_read_register_dummy (get_frame_pc (get_next_frame (frn)),
1602                                               get_frame_base (get_next_frame (frn)),
1603                                               IA64_PFS_REGNUM);
1604       else
1605         cfm = read_register (IA64_PFS_REGNUM);
1606
1607       bsp = get_frame_extra_info (frn)->bsp;
1608     }
1609   get_frame_extra_info (frame)->cfm = cfm;
1610   get_frame_extra_info (frame)->sof = cfm & 0x7f;
1611   get_frame_extra_info (frame)->sol = (cfm >> 7) & 0x7f;
1612   if (get_next_frame (frame) == 0
1613       || (get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME)
1614       || next_frame_is_call_dummy)
1615     get_frame_extra_info (frame)->bsp =
1616       rse_address_add (bsp, -get_frame_extra_info (frame)->sof);
1617   else
1618     get_frame_extra_info (frame)->bsp =
1619       rse_address_add (bsp, -get_frame_extra_info (frame)->sol);
1620
1621   get_frame_extra_info (frame)->after_prologue = 0;
1622   get_frame_extra_info (frame)->mem_stack_frame_size = -1;              /* Not yet determined */
1623   get_frame_extra_info (frame)->fp_reg = 0;
1624 }
1625
1626 static int
1627 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
1628 {
1629   switch (TYPE_CODE (t))
1630     {
1631     case TYPE_CODE_FLT:
1632       if (*etp)
1633         return TYPE_LENGTH (*etp) == TYPE_LENGTH (t);
1634       else
1635         {
1636           *etp = t;
1637           return 1;
1638         }
1639       break;
1640     case TYPE_CODE_ARRAY:
1641       return
1642         is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t)),
1643                                       etp);
1644       break;
1645     case TYPE_CODE_STRUCT:
1646       {
1647         int i;
1648
1649         for (i = 0; i < TYPE_NFIELDS (t); i++)
1650           if (!is_float_or_hfa_type_recurse
1651               (check_typedef (TYPE_FIELD_TYPE (t, i)), etp))
1652             return 0;
1653         return 1;
1654       }
1655       break;
1656     default:
1657       return 0;
1658       break;
1659     }
1660 }
1661
1662 /* Determine if the given type is one of the floating point types or
1663    and HFA (which is a struct, array, or combination thereof whose
1664    bottom-most elements are all of the same floating point type.) */
1665
1666 static struct type *
1667 is_float_or_hfa_type (struct type *t)
1668 {
1669   struct type *et = 0;
1670
1671   return is_float_or_hfa_type_recurse (t, &et) ? et : 0;
1672 }
1673
1674
1675 /* Return 1 if the alignment of T is such that the next even slot
1676    should be used.  Return 0, if the next available slot should
1677    be used.  (See section 8.5.1 of the IA-64 Software Conventions
1678    and Runtime manual.)  */
1679
1680 static int
1681 slot_alignment_is_next_even (struct type *t)
1682 {
1683   switch (TYPE_CODE (t))
1684     {
1685     case TYPE_CODE_INT:
1686     case TYPE_CODE_FLT:
1687       if (TYPE_LENGTH (t) > 8)
1688         return 1;
1689       else
1690         return 0;
1691     case TYPE_CODE_ARRAY:
1692       return
1693         slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t)));
1694     case TYPE_CODE_STRUCT:
1695       {
1696         int i;
1697
1698         for (i = 0; i < TYPE_NFIELDS (t); i++)
1699           if (slot_alignment_is_next_even
1700               (check_typedef (TYPE_FIELD_TYPE (t, i))))
1701             return 1;
1702         return 0;
1703       }
1704     default:
1705       return 0;
1706     }
1707 }
1708
1709 /* Attempt to find (and return) the global pointer for the given
1710    function.
1711
1712    This is a rather nasty bit of code searchs for the .dynamic section
1713    in the objfile corresponding to the pc of the function we're trying
1714    to call.  Once it finds the addresses at which the .dynamic section
1715    lives in the child process, it scans the Elf64_Dyn entries for a
1716    DT_PLTGOT tag.  If it finds one of these, the corresponding
1717    d_un.d_ptr value is the global pointer.  */
1718
1719 static CORE_ADDR
1720 generic_elf_find_global_pointer (CORE_ADDR faddr)
1721 {
1722   struct obj_section *faddr_sect;
1723
1724   faddr_sect = find_pc_section (faddr);
1725   if (faddr_sect != NULL)
1726     {
1727       struct obj_section *osect;
1728
1729       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1730         {
1731           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
1732             break;
1733         }
1734
1735       if (osect < faddr_sect->objfile->sections_end)
1736         {
1737           CORE_ADDR addr;
1738
1739           addr = osect->addr;
1740           while (addr < osect->endaddr)
1741             {
1742               int status;
1743               LONGEST tag;
1744               char buf[8];
1745
1746               status = target_read_memory (addr, buf, sizeof (buf));
1747               if (status != 0)
1748                 break;
1749               tag = extract_signed_integer (buf, sizeof (buf));
1750
1751               if (tag == DT_PLTGOT)
1752                 {
1753                   CORE_ADDR global_pointer;
1754
1755                   status = target_read_memory (addr + 8, buf, sizeof (buf));
1756                   if (status != 0)
1757                     break;
1758                   global_pointer = extract_unsigned_integer (buf, sizeof (buf));
1759
1760                   /* The payoff... */
1761                   return global_pointer;
1762                 }
1763
1764               if (tag == DT_NULL)
1765                 break;
1766
1767               addr += 16;
1768             }
1769         }
1770     }
1771   return 0;
1772 }
1773
1774 /* Given a function's address, attempt to find (and return) the
1775    corresponding (canonical) function descriptor.  Return 0 if
1776    not found. */
1777 static CORE_ADDR
1778 find_extant_func_descr (CORE_ADDR faddr)
1779 {
1780   struct obj_section *faddr_sect;
1781
1782   /* Return early if faddr is already a function descriptor */
1783   faddr_sect = find_pc_section (faddr);
1784   if (faddr_sect && strcmp (faddr_sect->the_bfd_section->name, ".opd") == 0)
1785     return faddr;
1786
1787   if (faddr_sect != NULL)
1788     {
1789       struct obj_section *osect;
1790       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1791         {
1792           if (strcmp (osect->the_bfd_section->name, ".opd") == 0)
1793             break;
1794         }
1795
1796       if (osect < faddr_sect->objfile->sections_end)
1797         {
1798           CORE_ADDR addr;
1799
1800           addr = osect->addr;
1801           while (addr < osect->endaddr)
1802             {
1803               int status;
1804               LONGEST faddr2;
1805               char buf[8];
1806
1807               status = target_read_memory (addr, buf, sizeof (buf));
1808               if (status != 0)
1809                 break;
1810               faddr2 = extract_signed_integer (buf, sizeof (buf));
1811
1812               if (faddr == faddr2)
1813                 return addr;
1814
1815               addr += 16;
1816             }
1817         }
1818     }
1819   return 0;
1820 }
1821
1822 /* Attempt to find a function descriptor corresponding to the
1823    given address.  If none is found, construct one on the
1824    stack using the address at fdaptr */
1825
1826 static CORE_ADDR
1827 find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
1828 {
1829   CORE_ADDR fdesc;
1830
1831   fdesc = find_extant_func_descr (faddr);
1832
1833   if (fdesc == 0)
1834     {
1835       CORE_ADDR global_pointer;
1836       char buf[16];
1837
1838       fdesc = *fdaptr;
1839       *fdaptr += 16;
1840
1841       global_pointer = FIND_GLOBAL_POINTER (faddr);
1842
1843       if (global_pointer == 0)
1844         global_pointer = read_register (IA64_GR1_REGNUM);
1845
1846       store_unsigned_integer (buf, 8, faddr);
1847       store_unsigned_integer (buf + 8, 8, global_pointer);
1848
1849       write_memory (fdesc, buf, 16);
1850     }
1851
1852   return fdesc;
1853 }
1854
1855 static CORE_ADDR
1856 ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1857                     int struct_return, CORE_ADDR struct_addr)
1858 {
1859   int argno;
1860   struct value *arg;
1861   struct type *type;
1862   int len, argoffset;
1863   int nslots, rseslots, memslots, slotnum, nfuncargs;
1864   int floatreg;
1865   CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr;
1866
1867   nslots = 0;
1868   nfuncargs = 0;
1869   /* Count the number of slots needed for the arguments */
1870   for (argno = 0; argno < nargs; argno++)
1871     {
1872       arg = args[argno];
1873       type = check_typedef (VALUE_TYPE (arg));
1874       len = TYPE_LENGTH (type);
1875
1876       if ((nslots & 1) && slot_alignment_is_next_even (type))
1877         nslots++;
1878
1879       if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1880         nfuncargs++;
1881
1882       nslots += (len + 7) / 8;
1883     }
1884
1885   /* Divvy up the slots between the RSE and the memory stack */
1886   rseslots = (nslots > 8) ? 8 : nslots;
1887   memslots = nslots - rseslots;
1888
1889   /* Allocate a new RSE frame */
1890   cfm = read_register (IA64_CFM_REGNUM);
1891
1892   bsp = read_register (IA64_BSP_REGNUM);
1893   bsp = rse_address_add (bsp, cfm & 0x7f);
1894   new_bsp = rse_address_add (bsp, rseslots);
1895   write_register (IA64_BSP_REGNUM, new_bsp);
1896
1897   pfs = read_register (IA64_PFS_REGNUM);
1898   pfs &= 0xc000000000000000LL;
1899   pfs |= (cfm & 0xffffffffffffLL);
1900   write_register (IA64_PFS_REGNUM, pfs);
1901
1902   cfm &= 0xc000000000000000LL;
1903   cfm |= rseslots;
1904   write_register (IA64_CFM_REGNUM, cfm);
1905
1906   /* We will attempt to find function descriptors in the .opd segment,
1907      but if we can't we'll construct them ourselves.  That being the
1908      case, we'll need to reserve space on the stack for them. */
1909   funcdescaddr = sp - nfuncargs * 16;
1910   funcdescaddr &= ~0xfLL;
1911
1912   /* Adjust the stack pointer to it's new value.  The calling conventions
1913      require us to have 16 bytes of scratch, plus whatever space is
1914      necessary for the memory slots and our function descriptors */
1915   sp = sp - 16 - (memslots + nfuncargs) * 8;
1916   sp &= ~0xfLL;                         /* Maintain 16 byte alignment */
1917
1918   /* Place the arguments where they belong.  The arguments will be
1919      either placed in the RSE backing store or on the memory stack.
1920      In addition, floating point arguments or HFAs are placed in
1921      floating point registers. */
1922   slotnum = 0;
1923   floatreg = IA64_FR8_REGNUM;
1924   for (argno = 0; argno < nargs; argno++)
1925     {
1926       struct type *float_elt_type;
1927
1928       arg = args[argno];
1929       type = check_typedef (VALUE_TYPE (arg));
1930       len = TYPE_LENGTH (type);
1931
1932       /* Special handling for function parameters */
1933       if (len == 8
1934           && TYPE_CODE (type) == TYPE_CODE_PTR
1935           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1936         {
1937           char val_buf[8];
1938
1939           store_unsigned_integer (val_buf, 8,
1940                                   find_func_descr (extract_unsigned_integer (VALUE_CONTENTS (arg), 8),
1941                                                    &funcdescaddr));
1942           if (slotnum < rseslots)
1943             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1944           else
1945             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1946           slotnum++;
1947           continue;
1948         }
1949
1950       /* Normal slots */
1951
1952       /* Skip odd slot if necessary...  */
1953       if ((slotnum & 1) && slot_alignment_is_next_even (type))
1954         slotnum++;
1955
1956       argoffset = 0;
1957       while (len > 0)
1958         {
1959           char val_buf[8];
1960
1961           memset (val_buf, 0, 8);
1962           memcpy (val_buf, VALUE_CONTENTS (arg) + argoffset, (len > 8) ? 8 : len);
1963
1964           if (slotnum < rseslots)
1965             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1966           else
1967             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1968
1969           argoffset += 8;
1970           len -= 8;
1971           slotnum++;
1972         }
1973
1974       /* Handle floating point types (including HFAs) */
1975       float_elt_type = is_float_or_hfa_type (type);
1976       if (float_elt_type != NULL)
1977         {
1978           argoffset = 0;
1979           len = TYPE_LENGTH (type);
1980           while (len > 0 && floatreg < IA64_FR16_REGNUM)
1981             {
1982               ia64_register_convert_to_raw (
1983                 float_elt_type,
1984                 floatreg,
1985                 VALUE_CONTENTS (arg) + argoffset,
1986                 &deprecated_registers[REGISTER_BYTE (floatreg)]);
1987               floatreg++;
1988               argoffset += TYPE_LENGTH (float_elt_type);
1989               len -= TYPE_LENGTH (float_elt_type);
1990             }
1991         }
1992     }
1993
1994   /* Store the struct return value in r8 if necessary. */
1995   if (struct_return)
1996     {
1997       store_unsigned_integer (&deprecated_registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
1998                               REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
1999                               struct_addr);
2000     }
2001
2002   /* Sync gdb's idea of what the registers are with the target. */
2003   target_store_registers (-1);
2004
2005   /* FIXME: This doesn't belong here!  Instead,
2006      DEPRECATED_SAVE_DUMMY_FRAME_TOS needs to be defined to call
2007      generic_save_dummy_frame_tos().  But at the time of this writing,
2008      DEPRECATED_SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so I chose to
2009      put this call here instead of using the old mechanisms.  Once
2010      DEPRECATED_SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do
2011      is add the line
2012
2013         set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
2014
2015      to ia64_gdbarch_init() and remove the line below. */
2016   generic_save_dummy_frame_tos (sp);
2017
2018   return sp;
2019 }
2020
2021 static CORE_ADDR
2022 ia64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
2023 {
2024   CORE_ADDR global_pointer = FIND_GLOBAL_POINTER (pc);
2025
2026   if (global_pointer != 0)
2027     write_register (IA64_GR1_REGNUM, global_pointer);
2028
2029   write_register (IA64_BR0_REGNUM, CALL_DUMMY_ADDRESS ());
2030   return sp;
2031 }
2032
2033 static void
2034 ia64_store_return_value (struct type *type, char *valbuf)
2035 {
2036   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2037     {
2038       ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
2039                                     &deprecated_registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
2040       target_store_registers (IA64_FR8_REGNUM);
2041     }
2042   else
2043     deprecated_write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
2044                                      valbuf, TYPE_LENGTH (type));
2045 }
2046
2047 static void
2048 ia64_pop_frame (void)
2049 {
2050   generic_pop_current_frame (ia64_pop_frame_regular);
2051 }
2052
2053 static void
2054 ia64_pop_frame_regular (struct frame_info *frame)
2055 {
2056   int regno;
2057   CORE_ADDR bsp, cfm, pfs;
2058
2059   DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
2060
2061   for (regno = 0; regno < ia64_num_regs; regno++)
2062     {
2063       if (get_frame_saved_regs (frame)[regno]
2064           && (!(IA64_GR32_REGNUM <= regno && regno <= IA64_GR127_REGNUM))
2065           && regno != pc_regnum
2066           && regno != sp_regnum
2067           && regno != IA64_PFS_REGNUM
2068           && regno != IA64_CFM_REGNUM
2069           && regno != IA64_BSP_REGNUM
2070           && regno != IA64_BSPSTORE_REGNUM)
2071         {
2072           write_register (regno,
2073                           read_memory_integer (get_frame_saved_regs (frame)[regno],
2074                                                REGISTER_RAW_SIZE (regno)));
2075         }
2076     }
2077
2078   write_register (sp_regnum, DEPRECATED_FRAME_CHAIN (frame));
2079   write_pc (DEPRECATED_FRAME_SAVED_PC (frame));
2080
2081   cfm = read_register (IA64_CFM_REGNUM);
2082
2083   if (get_frame_saved_regs (frame)[IA64_PFS_REGNUM])
2084     {
2085       pfs = read_memory_integer (get_frame_saved_regs (frame)[IA64_PFS_REGNUM],
2086                                  REGISTER_RAW_SIZE (IA64_PFS_REGNUM));
2087     }
2088   else
2089     pfs = read_register (IA64_PFS_REGNUM);
2090
2091   /* Compute the new bsp by *adding* the difference between the
2092      size of the frame and the size of the locals (both wrt the
2093      frame that we're going back to).  This seems kind of strange,
2094      especially since it seems like we ought to be subtracting the
2095      size of the locals... and we should; but the Linux kernel
2096      wants bsp to be set at the end of all used registers.  It's
2097      likely that this code will need to be revised to accomodate
2098      other operating systems. */
2099   bsp = rse_address_add (get_frame_extra_info (frame)->bsp,
2100                          (pfs & 0x7f) - ((pfs >> 7) & 0x7f));
2101   write_register (IA64_BSP_REGNUM, bsp);
2102
2103   /* FIXME: What becomes of the epilog count in the PFS? */
2104   cfm = (cfm & ~0xffffffffffffLL) | (pfs & 0xffffffffffffLL);
2105   write_register (IA64_CFM_REGNUM, cfm);
2106
2107   flush_cached_frames ();
2108 }
2109
2110 static void
2111 ia64_remote_translate_xfer_address (struct gdbarch *gdbarch,
2112                                     struct regcache *regcache,
2113                                     CORE_ADDR memaddr, int nr_bytes,
2114                                     CORE_ADDR *targ_addr, int *targ_len)
2115 {
2116   *targ_addr = memaddr;
2117   *targ_len  = nr_bytes;
2118 }
2119
2120 static void
2121 process_note_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
2122 {
2123   int *os_ident_ptr = obj;
2124   const char *name;
2125   unsigned int sectsize;
2126
2127   name = bfd_get_section_name (abfd, sect);
2128   sectsize = bfd_section_size (abfd, sect);
2129   if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
2130     {
2131       unsigned int name_length, data_length, note_type;
2132       char *note = alloca (sectsize);
2133
2134       bfd_get_section_contents (abfd, sect, note,
2135                                 (file_ptr) 0, (bfd_size_type) sectsize);
2136
2137       name_length = bfd_h_get_32 (abfd, note);
2138       data_length = bfd_h_get_32 (abfd, note + 4);
2139       note_type   = bfd_h_get_32 (abfd, note + 8);
2140
2141       if (name_length == 4 && data_length == 16 && note_type == 1
2142           && strcmp (note + 12, "GNU") == 0)
2143         {
2144           int os_number = bfd_h_get_32 (abfd, note + 16);
2145
2146           /* The case numbers are from abi-tags in glibc */
2147           switch (os_number)
2148             {
2149             case 0 :
2150               *os_ident_ptr = ELFOSABI_LINUX;
2151               break;
2152             case 1 :
2153               *os_ident_ptr = ELFOSABI_HURD;
2154               break;
2155             case 2 :
2156               *os_ident_ptr = ELFOSABI_SOLARIS;
2157               break;
2158             default :
2159               internal_error (__FILE__, __LINE__,
2160                               "process_note_abi_sections: unknown OS number %d", os_number);
2161               break;
2162             }
2163         }
2164     }
2165 }
2166
2167 static struct gdbarch *
2168 ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2169 {
2170   struct gdbarch *gdbarch;
2171   struct gdbarch_tdep *tdep;
2172   int os_ident;
2173
2174   if (info.abfd != NULL
2175       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2176     {
2177       os_ident = elf_elfheader (info.abfd)->e_ident[EI_OSABI];
2178
2179       /* If os_ident is 0, it is not necessarily the case that we're
2180          on a SYSV system.  (ELFOSABI_NONE is defined to be 0.)
2181          GNU/Linux uses a note section to record OS/ABI info, but
2182          leaves e_ident[EI_OSABI] zero.  So we have to check for note
2183          sections too. */
2184       if (os_ident == 0)
2185         {
2186           bfd_map_over_sections (info.abfd,
2187                                  process_note_abi_tag_sections,
2188                                  &os_ident);
2189         }
2190     }
2191   else
2192     os_ident = -1;
2193
2194   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2195        arches != NULL;
2196        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2197     {
2198       tdep = gdbarch_tdep (arches->gdbarch);
2199       if (tdep &&tdep->os_ident == os_ident)
2200         return arches->gdbarch;
2201     }
2202
2203   tdep = xmalloc (sizeof (struct gdbarch_tdep));
2204   gdbarch = gdbarch_alloc (&info, tdep);
2205   tdep->os_ident = os_ident;
2206
2207   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2208      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
2209   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
2210
2211   /* Set the method of obtaining the sigcontext addresses at which
2212      registers are saved.  The method of checking to see if
2213      native_find_global_pointer is nonzero to indicate that we're
2214      on AIX is kind of hokey, but I can't think of a better way
2215      to do it.  */
2216   if (os_ident == ELFOSABI_LINUX)
2217     tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
2218   else if (native_find_global_pointer != 0)
2219     tdep->sigcontext_register_address = ia64_aix_sigcontext_register_address;
2220   else
2221     tdep->sigcontext_register_address = 0;
2222
2223   /* We know that GNU/Linux won't have to resort to the
2224      native_find_global_pointer hackery.  But that's the only one we
2225      know about so far, so if native_find_global_pointer is set to
2226      something non-zero, then use it.  Otherwise fall back to using
2227      generic_elf_find_global_pointer.  This arrangement should (in
2228      theory) allow us to cross debug GNU/Linux binaries from an AIX
2229      machine.  */
2230   if (os_ident == ELFOSABI_LINUX)
2231     tdep->find_global_pointer = generic_elf_find_global_pointer;
2232   else if (native_find_global_pointer != 0)
2233     tdep->find_global_pointer = native_find_global_pointer;
2234   else
2235     tdep->find_global_pointer = generic_elf_find_global_pointer;
2236
2237   set_gdbarch_short_bit (gdbarch, 16);
2238   set_gdbarch_int_bit (gdbarch, 32);
2239   set_gdbarch_long_bit (gdbarch, 64);
2240   set_gdbarch_long_long_bit (gdbarch, 64);
2241   set_gdbarch_float_bit (gdbarch, 32);
2242   set_gdbarch_double_bit (gdbarch, 64);
2243   set_gdbarch_long_double_bit (gdbarch, 128);
2244   set_gdbarch_ptr_bit (gdbarch, 64);
2245
2246   set_gdbarch_num_regs (gdbarch, ia64_num_regs);
2247   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
2248   set_gdbarch_deprecated_fp_regnum (gdbarch, fp_regnum);
2249   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
2250   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
2251
2252   set_gdbarch_register_name (gdbarch, ia64_register_name);
2253   set_gdbarch_deprecated_register_size (gdbarch, 8);
2254   set_gdbarch_deprecated_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
2255   set_gdbarch_deprecated_register_byte (gdbarch, ia64_register_byte);
2256   set_gdbarch_deprecated_register_raw_size (gdbarch, ia64_register_raw_size);
2257   set_gdbarch_deprecated_max_register_raw_size (gdbarch, 16);
2258   set_gdbarch_deprecated_register_virtual_size (gdbarch, ia64_register_virtual_size);
2259   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 16);
2260   set_gdbarch_deprecated_register_virtual_type (gdbarch, ia64_register_virtual_type);
2261
2262   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
2263
2264   set_gdbarch_frameless_function_invocation (gdbarch, ia64_frameless_function_invocation);
2265
2266   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
2267
2268   set_gdbarch_deprecated_frame_chain (gdbarch, ia64_frame_chain);
2269   set_gdbarch_deprecated_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
2270
2271   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
2272   set_gdbarch_deprecated_get_saved_register (gdbarch, ia64_get_saved_register);
2273
2274   set_gdbarch_deprecated_register_convertible (gdbarch, ia64_register_convertible);
2275   set_gdbarch_deprecated_register_convert_to_virtual (gdbarch, ia64_register_convert_to_virtual);
2276   set_gdbarch_deprecated_register_convert_to_raw (gdbarch, ia64_register_convert_to_raw);
2277
2278   set_gdbarch_use_struct_convention (gdbarch, ia64_use_struct_convention);
2279   set_gdbarch_deprecated_extract_return_value (gdbarch, ia64_extract_return_value);
2280
2281   set_gdbarch_deprecated_store_struct_return (gdbarch, ia64_store_struct_return);
2282   set_gdbarch_deprecated_store_return_value (gdbarch, ia64_store_return_value);
2283   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
2284
2285   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
2286   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
2287   set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc);
2288   set_gdbarch_read_pc (gdbarch, ia64_read_pc);
2289   set_gdbarch_write_pc (gdbarch, ia64_write_pc);
2290
2291   /* Settings for calling functions in the inferior.  */
2292   set_gdbarch_deprecated_push_arguments (gdbarch, ia64_push_arguments);
2293   set_gdbarch_deprecated_push_return_address (gdbarch, ia64_push_return_address);
2294   set_gdbarch_deprecated_pop_frame (gdbarch, ia64_pop_frame);
2295
2296   set_gdbarch_deprecated_call_dummy_words (gdbarch, ia64_call_dummy_words);
2297   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
2298   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
2299   set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
2300   set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
2301
2302   /* We won't necessarily have a frame pointer and even if we do, it
2303      winds up being extraordinarly messy when attempting to find the
2304      frame chain.  So for the purposes of creating frames (which is
2305      all deprecated_read_fp() is used for), simply use the stack
2306      pointer value instead.  */
2307   set_gdbarch_deprecated_target_read_fp (gdbarch, ia64_read_fp);
2308
2309   /* Settings that should be unnecessary.  */
2310   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2311
2312   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
2313
2314   set_gdbarch_decr_pc_after_break (gdbarch, 0);
2315   set_gdbarch_function_start_offset (gdbarch, 0);
2316   set_gdbarch_frame_args_skip (gdbarch, 0);
2317
2318   set_gdbarch_remote_translate_xfer_address (
2319     gdbarch, ia64_remote_translate_xfer_address);
2320
2321   return gdbarch;
2322 }
2323
2324 extern initialize_file_ftype _initialize_ia64_tdep; /* -Wmissing-prototypes */
2325
2326 void
2327 _initialize_ia64_tdep (void)
2328 {
2329   register_gdbarch_init (bfd_arch_ia64, ia64_gdbarch_init);
2330
2331   deprecated_tm_print_insn = print_insn_ia64;
2332   deprecated_tm_print_insn_info.bytes_per_line = SLOT_MULTIPLIER;
2333 }