gdb/ia64-tdep.c

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