gdb/ia64-tdep.c

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