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