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