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