gdb/ia64-tdep.c

   1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
   2
   3    Copyright 1999, 2000, 2001, 2002 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 in
 671    other places.  (E.g, note that read_fp() is actually read_sp() in
 672    ia64_gdbarch_init() below.)
 673
 674    Okay, so what is the frame chain exactly?  It'll be the SP value
 675    at the time that the function in question was entered.
 676
 677    Note that this *should* actually the frame pointer for the current
 678    function!  But as I note above, if we were to attempt to find the
 679    address of the beginning of the previous frame, we'd waste a lot
 680    of cycles for no good reason.  So instead, we simply choose to
 681    represent the frame chain as the end of the previous frame instead
 682    of the beginning.  */
 683
 684 CORE_ADDR
 685 ia64_frame_chain (struct frame_info *frame)
 686 {
 687   if (frame->signal_handler_caller)
 688     return read_sigcontext_register (frame, sp_regnum);
 689   else if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 690     return frame->frame;
 691   else
 692     {
 693       FRAME_INIT_SAVED_REGS (frame);
 694       if (frame->saved_regs[IA64_VFP_REGNUM])
 695         return read_memory_integer (frame->saved_regs[IA64_VFP_REGNUM], 8);
 696       else
 697         return frame->frame + frame->extra_info->mem_stack_frame_size;
 698     }
 699 }
 700
 701 CORE_ADDR
 702 ia64_frame_saved_pc (struct frame_info *frame)
 703 {
 704   if (frame->signal_handler_caller)
 705     return read_sigcontext_register (frame, pc_regnum);
 706   else if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 707     return generic_read_register_dummy (frame->pc, frame->frame, pc_regnum);
 708   else
 709     {
 710       FRAME_INIT_SAVED_REGS (frame);
 711
 712       if (frame->saved_regs[IA64_VRAP_REGNUM])
 713         return read_memory_integer (frame->saved_regs[IA64_VRAP_REGNUM], 8);
 714       else if (frame->next && frame->next->signal_handler_caller)
 715         return read_sigcontext_register (frame->next, IA64_BR0_REGNUM);
 716       else      /* either frameless, or not far enough along in the prologue... */
 717         return ia64_saved_pc_after_call (frame);
 718     }
 719 }
 720
 721 /* Limit the number of skipped non-prologue instructions since examining
 722    of the prologue is expensive.  */
 723 static int max_skip_non_prologue_insns = 10;
 724
 725 /* Given PC representing the starting address of a function, and
 726    LIM_PC which is the (sloppy) limit to which to scan when looking
 727    for a prologue, attempt to further refine this limit by using
 728    the line data in the symbol table.  If successful, a better guess
 729    on where the prologue ends is returned, otherwise the previous
 730    value of lim_pc is returned.  TRUST_LIMIT is a pointer to a flag
 731    which will be set to indicate whether the returned limit may be
 732    used with no further scanning in the event that the function is
 733    frameless.  */
 734
 735 static CORE_ADDR
 736 refine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc, int *trust_limit)
 737 {
 738   struct symtab_and_line prologue_sal;
 739   CORE_ADDR start_pc = pc;
 740
 741   /* Start off not trusting the limit.  */
 742   *trust_limit = 0;
 743
 744   prologue_sal = find_pc_line (pc, 0);
 745   if (prologue_sal.line != 0)
 746     {
 747       int i;
 748       CORE_ADDR addr = prologue_sal.end;
 749
 750       /* Handle the case in which compiler's optimizer/scheduler
 751          has moved instructions into the prologue.  We scan ahead
 752          in the function looking for address ranges whose corresponding
 753          line number is less than or equal to the first one that we
 754          found for the function.  (It can be less than when the
 755          scheduler puts a body instruction before the first prologue
 756          instruction.)  */
 757       for (i = 2 * max_skip_non_prologue_insns;
 758            i > 0 && (lim_pc == 0 || addr < lim_pc);
 759            i--)
 760         {
 761           struct symtab_and_line sal;
 762
 763           sal = find_pc_line (addr, 0);
 764           if (sal.line == 0)
 765             break;
 766           if (sal.line <= prologue_sal.line
 767               && sal.symtab == prologue_sal.symtab)
 768             {
 769               prologue_sal = sal;
 770             }
 771           addr = sal.end;
 772         }
 773
 774       if (lim_pc == 0 || prologue_sal.end < lim_pc)
 775         {
 776           lim_pc = prologue_sal.end;
 777           if (start_pc == get_pc_function_start (lim_pc))
 778             *trust_limit = 1;
 779         }
 780     }
 781   return lim_pc;
 782 }
 783
 784 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
 785   || (8 <= (_regnum_) && (_regnum_) <= 11) \
 786   || (14 <= (_regnum_) && (_regnum_) <= 31))
 787 #define imm9(_instr_) \
 788   ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
 789    | (((_instr_) & 0x00008000000LL) >> 20) \
 790    | (((_instr_) & 0x00000001fc0LL) >> 6))
 791
 792 static CORE_ADDR
 793 examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
 794 {
 795   CORE_ADDR next_pc;
 796   CORE_ADDR last_prologue_pc = pc;
 797   instruction_type it;
 798   long long instr;
 799   int do_fsr_stuff = 0;
 800
 801   int cfm_reg  = 0;
 802   int ret_reg  = 0;
 803   int fp_reg   = 0;
 804   int unat_save_reg = 0;
 805   int pr_save_reg = 0;
 806   int mem_stack_frame_size = 0;
 807   int spill_reg   = 0;
 808   CORE_ADDR spill_addr = 0;
 809   char instores[8];
 810   char infpstores[8];
 811   int trust_limit;
 812
 813   memset (instores, 0, sizeof instores);
 814   memset (infpstores, 0, sizeof infpstores);
 815
 816   if (frame && !frame->saved_regs)
 817     {
 818       frame_saved_regs_zalloc (frame);
 819       do_fsr_stuff = 1;
 820     }
 821
 822   if (frame
 823       && !do_fsr_stuff
 824       && frame->extra_info->after_prologue != 0
 825       && frame->extra_info->after_prologue <= lim_pc)
 826     return frame->extra_info->after_prologue;
 827
 828   lim_pc = refine_prologue_limit (pc, lim_pc, &trust_limit);
 829
 830   /* Must start with an alloc instruction */
 831   next_pc = fetch_instruction (pc, &it, &instr);
 832   if (pc < lim_pc && next_pc
 833       && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL))
 834     {
 835       /* alloc */
 836       int sor = (int) ((instr & 0x00078000000LL) >> 27);
 837       int sol = (int) ((instr & 0x00007f00000LL) >> 20);
 838       int sof = (int) ((instr & 0x000000fe000LL) >> 13);
 839       /* Okay, so sor, sol, and sof aren't used right now; but perhaps
 840          we could compare against the size given to us via the cfm as
 841          either a sanity check or possibly to see if the frame has been
 842          changed by a later alloc instruction... */
 843       int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 844       cfm_reg = rN;
 845       last_prologue_pc = next_pc;
 846       pc = next_pc;
 847     }
 848   else
 849     {
 850       pc = lim_pc;      /* Frameless: We're done early.  */
 851       if (trust_limit)
 852         last_prologue_pc = lim_pc;
 853     }
 854
 855   /* Loop, looking for prologue instructions, keeping track of
 856      where preserved registers were spilled. */
 857   while (pc < lim_pc)
 858     {
 859       next_pc = fetch_instruction (pc, &it, &instr);
 860       if (next_pc == 0)
 861         break;
 862
 863       if ((it == B && ((instr & 0x1e1f800003f) != 0x04000000000))
 864           || ((instr & 0x3fLL) != 0LL))
 865         {
 866           /* Exit loop upon hitting a non-nop branch instruction
 867              or a predicated instruction. */
 868           break;
 869         }
 870       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00188000000LL))
 871         {
 872           /* Move from BR */
 873           int b2 = (int) ((instr & 0x0000000e000LL) >> 13);
 874           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 875           int qp = (int) (instr & 0x0000000003f);
 876
 877           if (qp == 0 && b2 == 0 && rN >= 32 && ret_reg == 0)
 878             {
 879               ret_reg = rN;
 880               last_prologue_pc = next_pc;
 881             }
 882         }
 883       else if ((it == I || it == M)
 884           && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
 885         {
 886           /* adds rN = imm14, rM   (or mov rN, rM  when imm14 is 0) */
 887           int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
 888                            | ((instr & 0x001f8000000LL) >> 20)
 889                            | ((instr & 0x000000fe000LL) >> 13));
 890           int rM = (int) ((instr & 0x00007f00000LL) >> 20);
 891           int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
 892           int qp = (int) (instr & 0x0000000003fLL);
 893
 894           if (qp == 0 && rN >= 32 && imm == 0 && rM == 12 && fp_reg == 0)
 895             {
 896               /* mov rN, r12 */
 897               fp_reg = rN;
 898               last_prologue_pc = next_pc;
 899             }
 900           else if (qp == 0 && rN == 12 && rM == 12)
 901             {
 902               /* adds r12, -mem_stack_frame_size, r12 */
 903               mem_stack_frame_size -= imm;
 904               last_prologue_pc = next_pc;
 905             }
 906           else if (qp == 0 && rN == 2
 907                 && ((rM == fp_reg && fp_reg != 0) || rM == 12))
 908             {
 909               /* adds r2, spilloffset, rFramePointer
 910                    or
 911                  adds r2, spilloffset, r12
 912
 913                  Get ready for stf.spill or st8.spill instructions.
 914                  The address to start spilling at is loaded into r2.
 915                  FIXME:  Why r2?  That's what gcc currently uses; it
 916                  could well be different for other compilers.  */
 917
 918               /* Hmm... whether or not this will work will depend on
 919                  where the pc is.  If it's still early in the prologue
 920                  this'll be wrong.  FIXME */
 921               spill_addr  = (frame ? frame->frame : 0)
 922                           + (rM == 12 ? 0 : mem_stack_frame_size)
 923                           + imm;
 924               spill_reg   = rN;
 925               last_prologue_pc = next_pc;
 926             }
 927         }
 928       else if (it == M
 929             && (   ((instr & 0x1efc0000000LL) == 0x0eec0000000LL)
 930                 || ((instr & 0x1ffc8000000LL) == 0x0cec0000000LL) ))
 931         {
 932           /* stf.spill [rN] = fM, imm9
 933              or
 934              stf.spill [rN] = fM  */
 935
 936           int imm = imm9(instr);
 937           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
 938           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
 939           int qp = (int) (instr & 0x0000000003fLL);
 940           if (qp == 0 && rN == spill_reg && spill_addr != 0
 941               && ((2 <= fM && fM <= 5) || (16 <= fM && fM <= 31)))
 942             {
 943               if (do_fsr_stuff)
 944                 frame->saved_regs[IA64_FR0_REGNUM + fM] = spill_addr;
 945
 946               if ((instr & 0x1efc0000000) == 0x0eec0000000)
 947                 spill_addr += imm;
 948               else
 949                 spill_addr = 0;         /* last one; must be done */
 950               last_prologue_pc = next_pc;
 951             }
 952         }
 953       else if ((it == M && ((instr & 0x1eff8000000LL) == 0x02110000000LL))
 954             || (it == I && ((instr & 0x1eff8000000LL) == 0x00050000000LL)) )
 955         {
 956           /* mov.m rN = arM
 957                or
 958              mov.i rN = arM */
 959
 960           int arM = (int) ((instr & 0x00007f00000LL) >> 20);
 961           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
 962           int qp  = (int) (instr & 0x0000000003fLL);
 963           if (qp == 0 && isScratch (rN) && arM == 36 /* ar.unat */)
 964             {
 965               /* We have something like "mov.m r3 = ar.unat".  Remember the
 966                  r3 (or whatever) and watch for a store of this register... */
 967               unat_save_reg = rN;
 968               last_prologue_pc = next_pc;
 969             }
 970         }
 971       else if (it == I && ((instr & 0x1eff8000000LL) == 0x00198000000LL))
 972         {
 973           /* mov rN = pr */
 974           int rN  = (int) ((instr & 0x00000001fc0LL) >> 6);
 975           int qp  = (int) (instr & 0x0000000003fLL);
 976           if (qp == 0 && isScratch (rN))
 977             {
 978               pr_save_reg = rN;
 979               last_prologue_pc = next_pc;
 980             }
 981         }
 982       else if (it == M
 983             && (   ((instr & 0x1ffc8000000LL) == 0x08cc0000000LL)
 984                 || ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)))
 985         {
 986           /* st8 [rN] = rM
 987               or
 988              st8 [rN] = rM, imm9 */
 989           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
 990           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
 991           int qp = (int) (instr & 0x0000000003fLL);
 992           if (qp == 0 && rN == spill_reg && spill_addr != 0
 993               && (rM == unat_save_reg || rM == pr_save_reg))
 994             {
 995               /* We've found a spill of either the UNAT register or the PR
 996                  register.  (Well, not exactly; what we've actually found is
 997                  a spill of the register that UNAT or PR was moved to).
 998                  Record that fact and move on... */
 999               if (rM == unat_save_reg)
1000                 {
1001                   /* Track UNAT register */
1002                   if (do_fsr_stuff)
1003                     frame->saved_regs[IA64_UNAT_REGNUM] = spill_addr;
1004                   unat_save_reg = 0;
1005                 }
1006               else
1007                 {
1008                   /* Track PR register */
1009                   if (do_fsr_stuff)
1010                     frame->saved_regs[IA64_PR_REGNUM] = spill_addr;
1011                   pr_save_reg = 0;
1012                 }
1013               if ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)
1014                 /* st8 [rN] = rM, imm9 */
1015                 spill_addr += imm9(instr);
1016               else
1017                 spill_addr = 0;         /* must be done spilling */
1018               last_prologue_pc = next_pc;
1019             }
1020           else if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1021             {
1022               /* Allow up to one store of each input register. */
1023               instores[rM-32] = 1;
1024               last_prologue_pc = next_pc;
1025             }
1026         }
1027       else if (it == M && ((instr & 0x1ff08000000LL) == 0x08c00000000LL))
1028         {
1029           /* One of
1030                st1 [rN] = rM
1031                st2 [rN] = rM
1032                st4 [rN] = rM
1033                st8 [rN] = rM
1034              Note that the st8 case is handled in the clause above.
1035
1036              Advance over stores of input registers. One store per input
1037              register is permitted. */
1038           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1039           int qp = (int) (instr & 0x0000000003fLL);
1040           if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1041             {
1042               instores[rM-32] = 1;
1043               last_prologue_pc = next_pc;
1044             }
1045         }
1046       else if (it == M && ((instr & 0x1ff88000000LL) == 0x0cc80000000LL))
1047         {
1048           /* Either
1049                stfs [rN] = fM
1050              or
1051                stfd [rN] = fM
1052
1053              Advance over stores of floating point input registers.  Again
1054              one store per register is permitted */
1055           int fM = (int) ((instr & 0x000000fe000LL) >> 13);
1056           int qp = (int) (instr & 0x0000000003fLL);
1057           if (qp == 0 && 8 <= fM && fM < 16 && !infpstores[fM - 8])
1058             {
1059               infpstores[fM-8] = 1;
1060               last_prologue_pc = next_pc;
1061             }
1062         }
1063       else if (it == M
1064             && (   ((instr & 0x1ffc8000000LL) == 0x08ec0000000LL)
1065                 || ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)))
1066         {
1067           /* st8.spill [rN] = rM
1068                or
1069              st8.spill [rN] = rM, imm9 */
1070           int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1071           int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1072           int qp = (int) (instr & 0x0000000003fLL);
1073           if (qp == 0 && rN == spill_reg && 4 <= rM && rM <= 7)
1074             {
1075               /* We've found a spill of one of the preserved general purpose
1076                  regs.  Record the spill address and advance the spill
1077                  register if appropriate. */
1078               if (do_fsr_stuff)
1079                 frame->saved_regs[IA64_GR0_REGNUM + rM] = spill_addr;
1080               if ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)
1081                 /* st8.spill [rN] = rM, imm9 */
1082                 spill_addr += imm9(instr);
1083               else
1084                 spill_addr = 0;         /* Done spilling */
1085               last_prologue_pc = next_pc;
1086             }
1087         }
1088
1089       pc = next_pc;
1090     }
1091
1092   if (do_fsr_stuff) {
1093     int i;
1094     CORE_ADDR addr;
1095     int sor, rrb_gr;
1096
1097     /* Extract the size of the rotating portion of the stack
1098        frame and the register rename base from the current
1099        frame marker. */
1100     sor = ((frame->extra_info->cfm >> 14) & 0xf) * 8;
1101     rrb_gr = (frame->extra_info->cfm >> 18) & 0x7f;
1102
1103     for (i = 0, addr = frame->extra_info->bsp;
1104          i < frame->extra_info->sof;
1105          i++, addr += 8)
1106       {
1107         if (IS_NaT_COLLECTION_ADDR (addr))
1108           {
1109             addr += 8;
1110           }
1111         if (i < sor)
1112           frame->saved_regs[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
1113             = addr;
1114         else
1115           frame->saved_regs[IA64_GR32_REGNUM + i] = addr;
1116
1117         if (i+32 == cfm_reg)
1118           frame->saved_regs[IA64_CFM_REGNUM] = addr;
1119         if (i+32 == ret_reg)
1120           frame->saved_regs[IA64_VRAP_REGNUM] = addr;
1121         if (i+32 == fp_reg)
1122           frame->saved_regs[IA64_VFP_REGNUM] = addr;
1123       }
1124   }
1125
1126   if (frame && frame->extra_info) {
1127     frame->extra_info->after_prologue = last_prologue_pc;
1128     frame->extra_info->mem_stack_frame_size = mem_stack_frame_size;
1129     frame->extra_info->fp_reg = fp_reg;
1130   }
1131
1132   return last_prologue_pc;
1133 }
1134
1135 CORE_ADDR
1136 ia64_skip_prologue (CORE_ADDR pc)
1137 {
1138   return examine_prologue (pc, pc+1024, 0);
1139 }
1140
1141 void
1142 ia64_frame_init_saved_regs (struct frame_info *frame)
1143 {
1144   if (frame->saved_regs)
1145     return;
1146
1147   if (frame->signal_handler_caller && SIGCONTEXT_REGISTER_ADDRESS)
1148     {
1149       int regno;
1150
1151       frame_saved_regs_zalloc (frame);
1152
1153       frame->saved_regs[IA64_VRAP_REGNUM] =
1154         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_IP_REGNUM);
1155       frame->saved_regs[IA64_CFM_REGNUM] =
1156         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CFM_REGNUM);
1157       frame->saved_regs[IA64_PSR_REGNUM] =
1158         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PSR_REGNUM);
1159 #if 0
1160       frame->saved_regs[IA64_BSP_REGNUM] =
1161         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_BSP_REGNUM);
1162 #endif
1163       frame->saved_regs[IA64_RNAT_REGNUM] =
1164         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_RNAT_REGNUM);
1165       frame->saved_regs[IA64_CCV_REGNUM] =
1166         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CCV_REGNUM);
1167       frame->saved_regs[IA64_UNAT_REGNUM] =
1168         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_UNAT_REGNUM);
1169       frame->saved_regs[IA64_FPSR_REGNUM] =
1170         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_FPSR_REGNUM);
1171       frame->saved_regs[IA64_PFS_REGNUM] =
1172         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PFS_REGNUM);
1173       frame->saved_regs[IA64_LC_REGNUM] =
1174         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_LC_REGNUM);
1175       for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
1176         if (regno != sp_regnum)
1177           frame->saved_regs[regno] =
1178             SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1179       for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1180         frame->saved_regs[regno] =
1181           SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1182       for (regno = IA64_FR2_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1183         frame->saved_regs[regno] =
1184           SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1185     }
1186   else
1187     {
1188       CORE_ADDR func_start;
1189
1190       func_start = get_pc_function_start (frame->pc);
1191       examine_prologue (func_start, frame->pc, frame);
1192     }
1193 }
1194
1195 void
1196 ia64_get_saved_register (char *raw_buffer,
1197                          int *optimized,
1198                          CORE_ADDR *addrp,
1199                          struct frame_info *frame,
1200                          int regnum,
1201                          enum lval_type *lval)
1202 {
1203   int is_dummy_frame;
1204
1205   if (!target_has_registers)
1206     error ("No registers.");
1207
1208   if (optimized != NULL)
1209     *optimized = 0;
1210
1211   if (addrp != NULL)
1212     *addrp = 0;
1213
1214   if (lval != NULL)
1215     *lval = not_lval;
1216
1217   is_dummy_frame = PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame);
1218
1219   if (regnum == SP_REGNUM && frame->next)
1220     {
1221       /* Handle SP values for all frames but the topmost. */
1222       store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->frame);
1223     }
1224   else if (regnum == IA64_BSP_REGNUM)
1225     {
1226       store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1227                      frame->extra_info->bsp);
1228     }
1229   else if (regnum == IA64_VFP_REGNUM)
1230     {
1231       /* If the function in question uses an automatic register (r32-r127)
1232          for the frame pointer, it'll be found by ia64_find_saved_register()
1233          above.  If the function lacks one of these frame pointers, we can
1234          still provide a value since we know the size of the frame */
1235       CORE_ADDR vfp = frame->frame + frame->extra_info->mem_stack_frame_size;
1236       store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
1237     }
1238   else if (IA64_PR0_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1239     {
1240       char *pr_raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
1241       int  pr_optim;
1242       enum lval_type pr_lval;
1243       CORE_ADDR pr_addr;
1244       int prN_val;
1245       ia64_get_saved_register (pr_raw_buffer, &pr_optim, &pr_addr,
1246                                frame, IA64_PR_REGNUM, &pr_lval);
1247       if (IA64_PR16_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1248         {
1249           /* Fetch predicate register rename base from current frame
1250              marker for this frame. */
1251           int rrb_pr = (frame->extra_info->cfm >> 32) & 0x3f;
1252
1253           /* Adjust the register number to account for register rotation. */
1254           regnum = IA64_PR16_REGNUM
1255                  + ((regnum - IA64_PR16_REGNUM) + rrb_pr) % 48;
1256         }
1257       prN_val = extract_bit_field ((unsigned char *) pr_raw_buffer,
1258                                    regnum - IA64_PR0_REGNUM, 1);
1259       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), prN_val);
1260     }
1261   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
1262     {
1263       char *unat_raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
1264       int  unat_optim;
1265       enum lval_type unat_lval;
1266       CORE_ADDR unat_addr;
1267       int unatN_val;
1268       ia64_get_saved_register (unat_raw_buffer, &unat_optim, &unat_addr,
1269                                frame, IA64_UNAT_REGNUM, &unat_lval);
1270       unatN_val = extract_bit_field ((unsigned char *) unat_raw_buffer,
1271                                    regnum - IA64_NAT0_REGNUM, 1);
1272       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
1273                               unatN_val);
1274     }
1275   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
1276     {
1277       int natval = 0;
1278       /* Find address of general register corresponding to nat bit we're
1279          interested in. */
1280       CORE_ADDR gr_addr = 0;
1281
1282       if (!is_dummy_frame)
1283         {
1284           FRAME_INIT_SAVED_REGS (frame);
1285           gr_addr = frame->saved_regs[ regnum - IA64_NAT0_REGNUM
1286                                               + IA64_GR0_REGNUM];
1287         }
1288       if (gr_addr)
1289         {
1290           /* Compute address of nat collection bits */
1291           CORE_ADDR nat_addr = gr_addr | 0x1f8;
1292           CORE_ADDR bsp = read_register (IA64_BSP_REGNUM);
1293           CORE_ADDR nat_collection;
1294           int nat_bit;
1295           /* If our nat collection address is bigger than bsp, we have to get
1296              the nat collection from rnat.  Otherwise, we fetch the nat
1297              collection from the computed address. */
1298           if (nat_addr >= bsp)
1299             nat_collection = read_register (IA64_RNAT_REGNUM);
1300           else
1301             nat_collection = read_memory_integer (nat_addr, 8);
1302           nat_bit = (gr_addr >> 3) & 0x3f;
1303           natval = (nat_collection >> nat_bit) & 1;
1304         }
1305       store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), natval);
1306     }
1307   else if (regnum == IA64_IP_REGNUM)
1308     {
1309       CORE_ADDR pc;
1310       if (frame->next)
1311         {
1312           /* FIXME: Set *addrp, *lval when possible. */
1313           pc = ia64_frame_saved_pc (frame->next);
1314         }
1315       else
1316         {
1317           pc = read_pc ();
1318         }
1319       store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_IP_REGNUM), pc);
1320     }
1321   else if (IA64_GR32_REGNUM <= regnum && regnum <= IA64_GR127_REGNUM)
1322     {
1323       CORE_ADDR addr = 0;
1324       if (!is_dummy_frame)
1325         {
1326           FRAME_INIT_SAVED_REGS (frame);
1327           addr = frame->saved_regs[regnum];
1328         }
1329
1330       if (addr != 0)
1331         {
1332           if (lval != NULL)
1333             *lval = lval_memory;
1334           if (addrp != NULL)
1335             *addrp = addr;
1336           read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
1337         }
1338       else
1339         {
1340           /* r32 - r127 must be fetchable via memory.  If they aren't,
1341              then the register is unavailable */
1342           memset (raw_buffer, 0, REGISTER_RAW_SIZE (regnum));
1343         }
1344     }
1345   else
1346     {
1347       if (IA64_FR32_REGNUM <= regnum && regnum <= IA64_FR127_REGNUM)
1348         {
1349           /* Fetch floating point register rename base from current
1350              frame marker for this frame. */
1351           int rrb_fr = (frame->extra_info->cfm >> 25) & 0x7f;
1352
1353           /* Adjust the floating point register number to account for
1354              register rotation. */
1355           regnum = IA64_FR32_REGNUM
1356                  + ((regnum - IA64_FR32_REGNUM) + rrb_fr) % 96;
1357         }
1358
1359       generic_get_saved_register (raw_buffer, optimized, addrp, frame,
1360                                   regnum, lval);
1361     }
1362 }
1363
1364 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1365    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1366    and TYPE is the type (which is known to be struct, union or array).  */
1367 int
1368 ia64_use_struct_convention (int gcc_p, struct type *type)
1369 {
1370   struct type *float_elt_type;
1371
1372   /* HFAs are structures (or arrays) consisting entirely of floating
1373      point values of the same length.  Up to 8 of these are returned
1374      in registers.  Don't use the struct convention when this is the
1375      case. */
1376   float_elt_type = is_float_or_hfa_type (type);
1377   if (float_elt_type != NULL
1378       && TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type) <= 8)
1379     return 0;
1380
1381   /* Other structs of length 32 or less are returned in r8-r11.
1382      Don't use the struct convention for those either. */
1383   return TYPE_LENGTH (type) > 32;
1384 }
1385
1386 void
1387 ia64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1388 {
1389   struct type *float_elt_type;
1390
1391   float_elt_type = is_float_or_hfa_type (type);
1392   if (float_elt_type != NULL)
1393     {
1394       int offset = 0;
1395       int regnum = IA64_FR8_REGNUM;
1396       int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
1397
1398       while (n-- > 0)
1399         {
1400           ia64_register_convert_to_virtual (regnum, float_elt_type,
1401             &regbuf[REGISTER_BYTE (regnum)], valbuf + offset);
1402           offset += TYPE_LENGTH (float_elt_type);
1403           regnum++;
1404         }
1405     }
1406   else
1407     memcpy (valbuf, &regbuf[REGISTER_BYTE (IA64_GR8_REGNUM)],
1408             TYPE_LENGTH (type));
1409 }
1410
1411 /* FIXME: Turn this into a stack of some sort.  Unfortunately, something
1412    like this is necessary though since the IA-64 calling conventions specify
1413    that r8 is not preserved. */
1414 static CORE_ADDR struct_return_address;
1415
1416 CORE_ADDR
1417 ia64_extract_struct_value_address (char *regbuf)
1418 {
1419   /* FIXME: See above. */
1420   return struct_return_address;
1421 }
1422
1423 void
1424 ia64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1425 {
1426   /* FIXME: See above. */
1427   /* Note that most of the work was done in ia64_push_arguments() */
1428   struct_return_address = addr;
1429 }
1430
1431 int
1432 ia64_frameless_function_invocation (struct frame_info *frame)
1433 {
1434   FRAME_INIT_SAVED_REGS (frame);
1435   return (frame->extra_info->mem_stack_frame_size == 0);
1436 }
1437
1438 CORE_ADDR
1439 ia64_saved_pc_after_call (struct frame_info *frame)
1440 {
1441   return read_register (IA64_BR0_REGNUM);
1442 }
1443
1444 CORE_ADDR
1445 ia64_frame_args_address (struct frame_info *frame)
1446 {
1447   /* frame->frame points at the SP for this frame; But we want the start
1448      of the frame, not the end.  Calling frame chain will get his for us. */
1449   return ia64_frame_chain (frame);
1450 }
1451
1452 CORE_ADDR
1453 ia64_frame_locals_address (struct frame_info *frame)
1454 {
1455   /* frame->frame points at the SP for this frame; But we want the start
1456      of the frame, not the end.  Calling frame chain will get his for us. */
1457   return ia64_frame_chain (frame);
1458 }
1459
1460 void
1461 ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
1462 {
1463   CORE_ADDR bsp, cfm;
1464   int next_frame_is_call_dummy = ((frame->next != NULL)
1465     && PC_IN_CALL_DUMMY (frame->next->pc, frame->next->frame,
1466                                           frame->next->frame));
1467
1468   frame->extra_info = (struct frame_extra_info *)
1469     frame_obstack_alloc (sizeof (struct frame_extra_info));
1470
1471   if (frame->next == 0)
1472     {
1473       bsp = read_register (IA64_BSP_REGNUM);
1474       cfm = read_register (IA64_CFM_REGNUM);
1475
1476     }
1477   else if (frame->next->signal_handler_caller)
1478     {
1479       bsp = read_sigcontext_register (frame->next, IA64_BSP_REGNUM);
1480       cfm = read_sigcontext_register (frame->next, IA64_CFM_REGNUM);
1481     }
1482   else if (next_frame_is_call_dummy)
1483     {
1484       bsp = generic_read_register_dummy (frame->next->pc, frame->next->frame,
1485                                          IA64_BSP_REGNUM);
1486       cfm = generic_read_register_dummy (frame->next->pc, frame->next->frame,
1487                                          IA64_CFM_REGNUM);
1488     }
1489   else
1490     {
1491       struct frame_info *frn = frame->next;
1492
1493       FRAME_INIT_SAVED_REGS (frn);
1494
1495       if (frn->saved_regs[IA64_CFM_REGNUM] != 0)
1496         cfm = read_memory_integer (frn->saved_regs[IA64_CFM_REGNUM], 8);
1497       else if (frn->next && frn->next->signal_handler_caller)
1498         cfm = read_sigcontext_register (frn->next, IA64_PFS_REGNUM);
1499       else if (frn->next
1500                && PC_IN_CALL_DUMMY (frn->next->pc, frn->next->frame,
1501                                                    frn->next->frame))
1502         cfm = generic_read_register_dummy (frn->next->pc, frn->next->frame,
1503                                            IA64_PFS_REGNUM);
1504       else
1505         cfm = read_register (IA64_PFS_REGNUM);
1506
1507       bsp = frn->extra_info->bsp;
1508     }
1509   frame->extra_info->cfm = cfm;
1510   frame->extra_info->sof = cfm & 0x7f;
1511   frame->extra_info->sol = (cfm >> 7) & 0x7f;
1512   if (frame->next == 0
1513       || frame->next->signal_handler_caller
1514       || next_frame_is_call_dummy)
1515     frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sof);
1516   else
1517     frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sol);
1518
1519   frame->extra_info->after_prologue = 0;
1520   frame->extra_info->mem_stack_frame_size = -1;         /* Not yet determined */
1521   frame->extra_info->fp_reg = 0;
1522 }
1523
1524 static int
1525 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
1526 {
1527   switch (TYPE_CODE (t))
1528     {
1529     case TYPE_CODE_FLT:
1530       if (*etp)
1531         return TYPE_LENGTH (*etp) == TYPE_LENGTH (t);
1532       else
1533         {
1534           *etp = t;
1535           return 1;
1536         }
1537       break;
1538     case TYPE_CODE_ARRAY:
1539       return
1540         is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t)),
1541                                       etp);
1542       break;
1543     case TYPE_CODE_STRUCT:
1544       {
1545         int i;
1546
1547         for (i = 0; i < TYPE_NFIELDS (t); i++)
1548           if (!is_float_or_hfa_type_recurse
1549               (check_typedef (TYPE_FIELD_TYPE (t, i)), etp))
1550             return 0;
1551         return 1;
1552       }
1553       break;
1554     default:
1555       return 0;
1556       break;
1557     }
1558 }
1559
1560 /* Determine if the given type is one of the floating point types or
1561    and HFA (which is a struct, array, or combination thereof whose
1562    bottom-most elements are all of the same floating point type.) */
1563
1564 static struct type *
1565 is_float_or_hfa_type (struct type *t)
1566 {
1567   struct type *et = 0;
1568
1569   return is_float_or_hfa_type_recurse (t, &et) ? et : 0;
1570 }
1571
1572
1573 /* Return 1 if the alignment of T is such that the next even slot
1574    should be used.  Return 0, if the next available slot should
1575    be used.  (See section 8.5.1 of the IA-64 Software Conventions
1576    and Runtime manual.)  */
1577
1578 static int
1579 slot_alignment_is_next_even (struct type *t)
1580 {
1581   switch (TYPE_CODE (t))
1582     {
1583     case TYPE_CODE_INT:
1584     case TYPE_CODE_FLT:
1585       if (TYPE_LENGTH (t) > 8)
1586         return 1;
1587       else
1588         return 0;
1589     case TYPE_CODE_ARRAY:
1590       return
1591         slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t)));
1592     case TYPE_CODE_STRUCT:
1593       {
1594         int i;
1595
1596         for (i = 0; i < TYPE_NFIELDS (t); i++)
1597           if (slot_alignment_is_next_even
1598               (check_typedef (TYPE_FIELD_TYPE (t, i))))
1599             return 1;
1600         return 0;
1601       }
1602     default:
1603       return 0;
1604     }
1605 }
1606
1607 /* Attempt to find (and return) the global pointer for the given
1608    function.
1609
1610    This is a rather nasty bit of code searchs for the .dynamic section
1611    in the objfile corresponding to the pc of the function we're trying
1612    to call.  Once it finds the addresses at which the .dynamic section
1613    lives in the child process, it scans the Elf64_Dyn entries for a
1614    DT_PLTGOT tag.  If it finds one of these, the corresponding
1615    d_un.d_ptr value is the global pointer.  */
1616
1617 static CORE_ADDR
1618 generic_elf_find_global_pointer (CORE_ADDR faddr)
1619 {
1620   struct obj_section *faddr_sect;
1621
1622   faddr_sect = find_pc_section (faddr);
1623   if (faddr_sect != NULL)
1624     {
1625       struct obj_section *osect;
1626
1627       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1628         {
1629           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
1630             break;
1631         }
1632
1633       if (osect < faddr_sect->objfile->sections_end)
1634         {
1635           CORE_ADDR addr;
1636
1637           addr = osect->addr;
1638           while (addr < osect->endaddr)
1639             {
1640               int status;
1641               LONGEST tag;
1642               char buf[8];
1643
1644               status = target_read_memory (addr, buf, sizeof (buf));
1645               if (status != 0)
1646                 break;
1647               tag = extract_signed_integer (buf, sizeof (buf));
1648
1649               if (tag == DT_PLTGOT)
1650                 {
1651                   CORE_ADDR global_pointer;
1652
1653                   status = target_read_memory (addr + 8, buf, sizeof (buf));
1654                   if (status != 0)
1655                     break;
1656                   global_pointer = extract_address (buf, sizeof (buf));
1657
1658                   /* The payoff... */
1659                   return global_pointer;
1660                 }
1661
1662               if (tag == DT_NULL)
1663                 break;
1664
1665               addr += 16;
1666             }
1667         }
1668     }
1669   return 0;
1670 }
1671
1672 /* Given a function's address, attempt to find (and return) the
1673    corresponding (canonical) function descriptor.  Return 0 if
1674    not found. */
1675 static CORE_ADDR
1676 find_extant_func_descr (CORE_ADDR faddr)
1677 {
1678   struct obj_section *faddr_sect;
1679
1680   /* Return early if faddr is already a function descriptor */
1681   faddr_sect = find_pc_section (faddr);
1682   if (faddr_sect && strcmp (faddr_sect->the_bfd_section->name, ".opd") == 0)
1683     return faddr;
1684
1685   if (faddr_sect != NULL)
1686     {
1687       struct obj_section *osect;
1688       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1689         {
1690           if (strcmp (osect->the_bfd_section->name, ".opd") == 0)
1691             break;
1692         }
1693
1694       if (osect < faddr_sect->objfile->sections_end)
1695         {
1696           CORE_ADDR addr;
1697
1698           addr = osect->addr;
1699           while (addr < osect->endaddr)
1700             {
1701               int status;
1702               LONGEST faddr2;
1703               char buf[8];
1704
1705               status = target_read_memory (addr, buf, sizeof (buf));
1706               if (status != 0)
1707                 break;
1708               faddr2 = extract_signed_integer (buf, sizeof (buf));
1709
1710               if (faddr == faddr2)
1711                 return addr;
1712
1713               addr += 16;
1714             }
1715         }
1716     }
1717   return 0;
1718 }
1719
1720 /* Attempt to find a function descriptor corresponding to the
1721    given address.  If none is found, construct one on the
1722    stack using the address at fdaptr */
1723
1724 static CORE_ADDR
1725 find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
1726 {
1727   CORE_ADDR fdesc;
1728
1729   fdesc = find_extant_func_descr (faddr);
1730
1731   if (fdesc == 0)
1732     {
1733       CORE_ADDR global_pointer;
1734       char buf[16];
1735
1736       fdesc = *fdaptr;
1737       *fdaptr += 16;
1738
1739       global_pointer = FIND_GLOBAL_POINTER (faddr);
1740
1741       if (global_pointer == 0)
1742         global_pointer = read_register (IA64_GR1_REGNUM);
1743
1744       store_address (buf, 8, faddr);
1745       store_address (buf + 8, 8, global_pointer);
1746
1747       write_memory (fdesc, buf, 16);
1748     }
1749
1750   return fdesc;
1751 }
1752
1753 CORE_ADDR
1754 ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1755                     int struct_return, CORE_ADDR struct_addr)
1756 {
1757   int argno;
1758   struct value *arg;
1759   struct type *type;
1760   int len, argoffset;
1761   int nslots, rseslots, memslots, slotnum, nfuncargs;
1762   int floatreg;
1763   CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr;
1764
1765   nslots = 0;
1766   nfuncargs = 0;
1767   /* Count the number of slots needed for the arguments */
1768   for (argno = 0; argno < nargs; argno++)
1769     {
1770       arg = args[argno];
1771       type = check_typedef (VALUE_TYPE (arg));
1772       len = TYPE_LENGTH (type);
1773
1774       if ((nslots & 1) && slot_alignment_is_next_even (type))
1775         nslots++;
1776
1777       if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1778         nfuncargs++;
1779
1780       nslots += (len + 7) / 8;
1781     }
1782
1783   /* Divvy up the slots between the RSE and the memory stack */
1784   rseslots = (nslots > 8) ? 8 : nslots;
1785   memslots = nslots - rseslots;
1786
1787   /* Allocate a new RSE frame */
1788   cfm = read_register (IA64_CFM_REGNUM);
1789
1790   bsp = read_register (IA64_BSP_REGNUM);
1791   bsp = rse_address_add (bsp, cfm & 0x7f);
1792   new_bsp = rse_address_add (bsp, rseslots);
1793   write_register (IA64_BSP_REGNUM, new_bsp);
1794
1795   pfs = read_register (IA64_PFS_REGNUM);
1796   pfs &= 0xc000000000000000LL;
1797   pfs |= (cfm & 0xffffffffffffLL);
1798   write_register (IA64_PFS_REGNUM, pfs);
1799
1800   cfm &= 0xc000000000000000LL;
1801   cfm |= rseslots;
1802   write_register (IA64_CFM_REGNUM, cfm);
1803
1804   /* We will attempt to find function descriptors in the .opd segment,
1805      but if we can't we'll construct them ourselves.  That being the
1806      case, we'll need to reserve space on the stack for them. */
1807   funcdescaddr = sp - nfuncargs * 16;
1808   funcdescaddr &= ~0xfLL;
1809
1810   /* Adjust the stack pointer to it's new value.  The calling conventions
1811      require us to have 16 bytes of scratch, plus whatever space is
1812      necessary for the memory slots and our function descriptors */
1813   sp = sp - 16 - (memslots + nfuncargs) * 8;
1814   sp &= ~0xfLL;                         /* Maintain 16 byte alignment */
1815
1816   /* Place the arguments where they belong.  The arguments will be
1817      either placed in the RSE backing store or on the memory stack.
1818      In addition, floating point arguments or HFAs are placed in
1819      floating point registers. */
1820   slotnum = 0;
1821   floatreg = IA64_FR8_REGNUM;
1822   for (argno = 0; argno < nargs; argno++)
1823     {
1824       struct type *float_elt_type;
1825
1826       arg = args[argno];
1827       type = check_typedef (VALUE_TYPE (arg));
1828       len = TYPE_LENGTH (type);
1829
1830       /* Special handling for function parameters */
1831       if (len == 8
1832           && TYPE_CODE (type) == TYPE_CODE_PTR
1833           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1834         {
1835           char val_buf[8];
1836
1837           store_address (val_buf, 8,
1838             find_func_descr (extract_address (VALUE_CONTENTS (arg), 8),
1839                              &funcdescaddr));
1840           if (slotnum < rseslots)
1841             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1842           else
1843             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1844           slotnum++;
1845           continue;
1846         }
1847
1848       /* Normal slots */
1849
1850       /* Skip odd slot if necessary...  */
1851       if ((slotnum & 1) && slot_alignment_is_next_even (type))
1852         slotnum++;
1853
1854       argoffset = 0;
1855       while (len > 0)
1856         {
1857           char val_buf[8];
1858
1859           memset (val_buf, 0, 8);
1860           memcpy (val_buf, VALUE_CONTENTS (arg) + argoffset, (len > 8) ? 8 : len);
1861
1862           if (slotnum < rseslots)
1863             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1864           else
1865             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1866
1867           argoffset += 8;
1868           len -= 8;
1869           slotnum++;
1870         }
1871
1872       /* Handle floating point types (including HFAs) */
1873       float_elt_type = is_float_or_hfa_type (type);
1874       if (float_elt_type != NULL)
1875         {
1876           argoffset = 0;
1877           len = TYPE_LENGTH (type);
1878           while (len > 0 && floatreg < IA64_FR16_REGNUM)
1879             {
1880               ia64_register_convert_to_raw (
1881                 float_elt_type,
1882                 floatreg,
1883                 VALUE_CONTENTS (arg) + argoffset,
1884                 &registers[REGISTER_BYTE (floatreg)]);
1885               floatreg++;
1886               argoffset += TYPE_LENGTH (float_elt_type);
1887               len -= TYPE_LENGTH (float_elt_type);
1888             }
1889         }
1890     }
1891
1892   /* Store the struct return value in r8 if necessary. */
1893   if (struct_return)
1894     {
1895       store_address (&registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
1896                      REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
1897                      struct_addr);
1898     }
1899
1900   /* Sync gdb's idea of what the registers are with the target. */
1901   target_store_registers (-1);
1902
1903   /* FIXME: This doesn't belong here!  Instead, SAVE_DUMMY_FRAME_TOS needs
1904      to be defined to call generic_save_dummy_frame_tos().  But at the
1905      time of this writing, SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so
1906      I chose to put this call here instead of using the old mechanisms.
1907      Once SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do is add the
1908      line
1909
1910         set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1911
1912      to ia64_gdbarch_init() and remove the line below. */
1913   generic_save_dummy_frame_tos (sp);
1914
1915   return sp;
1916 }
1917
1918 CORE_ADDR
1919 ia64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1920 {
1921   CORE_ADDR global_pointer = FIND_GLOBAL_POINTER (pc);
1922
1923   if (global_pointer != 0)
1924     write_register (IA64_GR1_REGNUM, global_pointer);
1925
1926   write_register (IA64_BR0_REGNUM, CALL_DUMMY_ADDRESS ());
1927   return sp;
1928 }
1929
1930 void
1931 ia64_store_return_value (struct type *type, char *valbuf)
1932 {
1933   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1934     {
1935       ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
1936                                   &registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
1937       target_store_registers (IA64_FR8_REGNUM);
1938     }
1939   else
1940     write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
1941                           valbuf, TYPE_LENGTH (type));
1942 }
1943
1944 void
1945 ia64_pop_frame (void)
1946 {
1947   generic_pop_current_frame (ia64_pop_frame_regular);
1948 }
1949
1950 static void
1951 ia64_pop_frame_regular (struct frame_info *frame)
1952 {
1953   int regno;
1954   CORE_ADDR bsp, cfm, pfs;
1955
1956   FRAME_INIT_SAVED_REGS (frame);
1957
1958   for (regno = 0; regno < ia64_num_regs; regno++)
1959     {
1960       if (frame->saved_regs[regno]
1961           && (!(IA64_GR32_REGNUM <= regno && regno <= IA64_GR127_REGNUM))
1962           && regno != pc_regnum
1963           && regno != sp_regnum
1964           && regno != IA64_PFS_REGNUM
1965           && regno != IA64_CFM_REGNUM
1966           && regno != IA64_BSP_REGNUM
1967           && regno != IA64_BSPSTORE_REGNUM)
1968         {
1969           write_register (regno,
1970                           read_memory_integer (frame->saved_regs[regno],
1971                                                REGISTER_RAW_SIZE (regno)));
1972         }
1973     }
1974
1975   write_register (sp_regnum, FRAME_CHAIN (frame));
1976   write_pc (FRAME_SAVED_PC (frame));
1977
1978   cfm = read_register (IA64_CFM_REGNUM);
1979
1980   if (frame->saved_regs[IA64_PFS_REGNUM])
1981     {
1982       pfs = read_memory_integer (frame->saved_regs[IA64_PFS_REGNUM],
1983                                  REGISTER_RAW_SIZE (IA64_PFS_REGNUM));
1984     }
1985   else
1986     pfs = read_register (IA64_PFS_REGNUM);
1987
1988   /* Compute the new bsp by *adding* the difference between the
1989      size of the frame and the size of the locals (both wrt the
1990      frame that we're going back to).  This seems kind of strange,
1991      especially since it seems like we ought to be subtracting the
1992      size of the locals... and we should; but the Linux kernel
1993      wants bsp to be set at the end of all used registers.  It's
1994      likely that this code will need to be revised to accomodate
1995      other operating systems. */
1996   bsp = rse_address_add (frame->extra_info->bsp,
1997                          (pfs & 0x7f) - ((pfs >> 7) & 0x7f));
1998   write_register (IA64_BSP_REGNUM, bsp);
1999
2000   /* FIXME: What becomes of the epilog count in the PFS? */
2001   cfm = (cfm & ~0xffffffffffffLL) | (pfs & 0xffffffffffffLL);
2002   write_register (IA64_CFM_REGNUM, cfm);
2003
2004   flush_cached_frames ();
2005 }
2006
2007 static void
2008 ia64_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
2009                                     CORE_ADDR *targ_addr, int *targ_len)
2010 {
2011   *targ_addr = memaddr;
2012   *targ_len  = nr_bytes;
2013 }
2014
2015 static void
2016 process_note_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
2017 {
2018   int *os_ident_ptr = obj;
2019   const char *name;
2020   unsigned int sectsize;
2021
2022   name = bfd_get_section_name (abfd, sect);
2023   sectsize = bfd_section_size (abfd, sect);
2024   if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
2025     {
2026       unsigned int name_length, data_length, note_type;
2027       char *note = alloca (sectsize);
2028
2029       bfd_get_section_contents (abfd, sect, note,
2030                                 (file_ptr) 0, (bfd_size_type) sectsize);
2031
2032       name_length = bfd_h_get_32 (abfd, note);
2033       data_length = bfd_h_get_32 (abfd, note + 4);
2034       note_type   = bfd_h_get_32 (abfd, note + 8);
2035
2036       if (name_length == 4 && data_length == 16 && note_type == 1
2037           && strcmp (note + 12, "GNU") == 0)
2038         {
2039           int os_number = bfd_h_get_32 (abfd, note + 16);
2040
2041           /* The case numbers are from abi-tags in glibc */
2042           switch (os_number)
2043             {
2044             case 0 :
2045               *os_ident_ptr = ELFOSABI_LINUX;
2046               break;
2047             case 1 :
2048               *os_ident_ptr = ELFOSABI_HURD;
2049               break;
2050             case 2 :
2051               *os_ident_ptr = ELFOSABI_SOLARIS;
2052               break;
2053             default :
2054               internal_error (__FILE__, __LINE__,
2055                               "process_note_abi_sections: unknown OS number %d", os_number);
2056               break;
2057             }
2058         }
2059     }
2060 }
2061
2062 static struct gdbarch *
2063 ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2064 {
2065   struct gdbarch *gdbarch;
2066   struct gdbarch_tdep *tdep;
2067   int os_ident;
2068
2069   if (info.abfd != NULL
2070       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2071     {
2072       os_ident = elf_elfheader (info.abfd)->e_ident[EI_OSABI];
2073
2074       /* If os_ident is 0, it is not necessarily the case that we're
2075          on a SYSV system.  (ELFOSABI_NONE is defined to be 0.)
2076          GNU/Linux uses a note section to record OS/ABI info, but
2077          leaves e_ident[EI_OSABI] zero.  So we have to check for note
2078          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       tdep = gdbarch_tdep (arches->gdbarch);
2094       if (tdep &&tdep->os_ident == os_ident)
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 GNU/Linux won't have to resort to the
2116      native_find_global_pointer hackery.  But that's the only one we
2117      know about so far, so if native_find_global_pointer is set to
2118      something non-zero, then use it.  Otherwise fall back to using
2119      generic_elf_find_global_pointer.  This arrangement should (in
2120      theory) allow us to cross debug GNU/Linux binaries from an AIX
2121      machine.  */
2122   if (os_ident == ELFOSABI_LINUX)
2123     tdep->find_global_pointer = generic_elf_find_global_pointer;
2124   else if (native_find_global_pointer != 0)
2125     tdep->find_global_pointer = native_find_global_pointer;
2126   else
2127     tdep->find_global_pointer = generic_elf_find_global_pointer;
2128
2129   set_gdbarch_short_bit (gdbarch, 16);
2130   set_gdbarch_int_bit (gdbarch, 32);
2131   set_gdbarch_long_bit (gdbarch, 64);
2132   set_gdbarch_long_long_bit (gdbarch, 64);
2133   set_gdbarch_float_bit (gdbarch, 32);
2134   set_gdbarch_double_bit (gdbarch, 64);
2135   set_gdbarch_long_double_bit (gdbarch, 64);
2136   set_gdbarch_ptr_bit (gdbarch, 64);
2137
2138   set_gdbarch_num_regs (gdbarch, ia64_num_regs);
2139   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
2140   set_gdbarch_fp_regnum (gdbarch, fp_regnum);
2141   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
2142   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
2143
2144   set_gdbarch_register_name (gdbarch, ia64_register_name);
2145   set_gdbarch_register_size (gdbarch, 8);
2146   set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
2147   set_gdbarch_register_byte (gdbarch, ia64_register_byte);
2148   set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
2149   set_gdbarch_max_register_raw_size (gdbarch, 16);
2150   set_gdbarch_register_virtual_size (gdbarch, ia64_register_virtual_size);
2151   set_gdbarch_max_register_virtual_size (gdbarch, 16);
2152   set_gdbarch_register_virtual_type (gdbarch, ia64_register_virtual_type);
2153
2154   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
2155
2156   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
2157   set_gdbarch_frameless_function_invocation (gdbarch, ia64_frameless_function_invocation);
2158
2159   set_gdbarch_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
2160
2161   set_gdbarch_frame_chain (gdbarch, ia64_frame_chain);
2162   set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
2163   set_gdbarch_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
2164
2165   set_gdbarch_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
2166   set_gdbarch_get_saved_register (gdbarch, ia64_get_saved_register);
2167
2168   set_gdbarch_register_convertible (gdbarch, ia64_register_convertible);
2169   set_gdbarch_register_convert_to_virtual (gdbarch, ia64_register_convert_to_virtual);
2170   set_gdbarch_register_convert_to_raw (gdbarch, ia64_register_convert_to_raw);
2171
2172   set_gdbarch_use_struct_convention (gdbarch, ia64_use_struct_convention);
2173   set_gdbarch_extract_return_value (gdbarch, ia64_extract_return_value);
2174
2175   set_gdbarch_store_struct_return (gdbarch, ia64_store_struct_return);
2176   set_gdbarch_store_return_value (gdbarch, ia64_store_return_value);
2177   set_gdbarch_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
2178
2179   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
2180   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
2181   set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc);
2182   set_gdbarch_read_pc (gdbarch, ia64_read_pc);
2183   set_gdbarch_write_pc (gdbarch, ia64_write_pc);
2184
2185   /* Settings for calling functions in the inferior.  */
2186   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
2187   set_gdbarch_call_dummy_length (gdbarch, 0);
2188   set_gdbarch_push_arguments (gdbarch, ia64_push_arguments);
2189   set_gdbarch_push_return_address (gdbarch, ia64_push_return_address);
2190   set_gdbarch_pop_frame (gdbarch, ia64_pop_frame);
2191
2192   set_gdbarch_call_dummy_p (gdbarch, 1);
2193   set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
2194   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
2195   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
2196   set_gdbarch_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
2197   set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
2198   set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
2199
2200   /* We won't necessarily have a frame pointer and even if we do,
2201      it winds up being extraordinarly messy when attempting to find
2202      the frame chain.  So for the purposes of creating frames (which
2203      is all read_fp() is used for), simply use the stack pointer value
2204      instead.  */
2205   set_gdbarch_read_fp (gdbarch, generic_target_read_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   set_gdbarch_frame_args_skip (gdbarch, 0);
2225
2226   set_gdbarch_remote_translate_xfer_address (
2227     gdbarch, ia64_remote_translate_xfer_address);
2228
2229   return gdbarch;
2230 }
2231
2232 void
2233 _initialize_ia64_tdep (void)
2234 {
2235   register_gdbarch_init (bfd_arch_ia64, ia64_gdbarch_init);
2236
2237   tm_print_insn = print_insn_ia64;
2238   tm_print_insn_info.bytes_per_line = SLOT_MULTIPLIER;
2239 }