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_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 (!(get_frame_type (frame) == SIGTRAMP_FRAME))
 332     internal_error (__FILE__, __LINE__,
 333                     "read_sigcontext_register: frame not a signal trampoline");
 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 ((get_frame_type (frame) == SIGTRAMP_FRAME))
 707     return read_sigcontext_register (frame, sp_regnum);
 708   else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
 709     return frame->frame;
 710   else
 711     {
 712       FRAME_INIT_SAVED_REGS (frame);
 713       if (get_frame_saved_regs (frame)[IA64_VFP_REGNUM])
 714         return read_memory_integer (get_frame_saved_regs (frame)[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 ((get_frame_type (frame) == SIGTRAMP_FRAME))
 724     return read_sigcontext_register (frame, pc_regnum);
 725   else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
 726     return deprecated_read_register_dummy (get_frame_pc (frame), frame->frame, pc_regnum);
 727   else
 728     {
 729       FRAME_INIT_SAVED_REGS (frame);
 730
 731       if (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM])
 732         return read_memory_integer (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM], 8);
 733       else if (frame->next && (get_frame_type (frame->next) == SIGTRAMP_FRAME))
 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 && !get_frame_saved_regs (frame))
 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                 get_frame_saved_regs (frame)[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                     get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] = spill_addr;
1023                   unat_save_reg = 0;
1024                 }
1025               else
1026                 {
1027                   /* Track PR register */
1028                   if (do_fsr_stuff)
1029                     get_frame_saved_regs (frame)[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                 get_frame_saved_regs (frame)[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           get_frame_saved_regs (frame)[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
1132             = addr;
1133         else
1134           get_frame_saved_regs (frame)[IA64_GR32_REGNUM + i] = addr;
1135
1136         if (i+32 == cfm_reg)
1137           get_frame_saved_regs (frame)[IA64_CFM_REGNUM] = addr;
1138         if (i+32 == ret_reg)
1139           get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] = addr;
1140         if (i+32 == fp_reg)
1141           get_frame_saved_regs (frame)[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 (get_frame_saved_regs (frame))
1164     return;
1165
1166   if ((get_frame_type (frame) == SIGTRAMP_FRAME) && SIGCONTEXT_REGISTER_ADDRESS)
1167     {
1168       int regno;
1169
1170       frame_saved_regs_zalloc (frame);
1171
1172       get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] =
1173         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_IP_REGNUM);
1174       get_frame_saved_regs (frame)[IA64_CFM_REGNUM] =
1175         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CFM_REGNUM);
1176       get_frame_saved_regs (frame)[IA64_PSR_REGNUM] =
1177         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PSR_REGNUM);
1178 #if 0
1179       get_frame_saved_regs (frame)[IA64_BSP_REGNUM] =
1180         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_BSP_REGNUM);
1181 #endif
1182       get_frame_saved_regs (frame)[IA64_RNAT_REGNUM] =
1183         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_RNAT_REGNUM);
1184       get_frame_saved_regs (frame)[IA64_CCV_REGNUM] =
1185         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CCV_REGNUM);
1186       get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] =
1187         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_UNAT_REGNUM);
1188       get_frame_saved_regs (frame)[IA64_FPSR_REGNUM] =
1189         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_FPSR_REGNUM);
1190       get_frame_saved_regs (frame)[IA64_PFS_REGNUM] =
1191         SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PFS_REGNUM);
1192       get_frame_saved_regs (frame)[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           get_frame_saved_regs (frame)[regno] =
1197             SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1198       for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1199         get_frame_saved_regs (frame)[regno] =
1200           SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1201       for (regno = IA64_FR2_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1202         get_frame_saved_regs (frame)[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 (get_frame_pc (frame));
1210       examine_prologue (func_start, get_frame_pc (frame), 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 = DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), 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 = get_frame_saved_regs (frame)[ 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 = get_frame_saved_regs (frame)[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       deprecated_generic_get_saved_register (raw_buffer, optimized, addrp,
1379                                              frame, 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     && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame->next), frame->next->frame,
1485                                           frame->next->frame));
1486
1487   frame_extra_info_zalloc (frame, sizeof (struct frame_extra_info));
1488
1489   if (frame->next == 0)
1490     {
1491       bsp = read_register (IA64_BSP_REGNUM);
1492       cfm = read_register (IA64_CFM_REGNUM);
1493
1494     }
1495   else if ((get_frame_type (frame->next) == SIGTRAMP_FRAME))
1496     {
1497       bsp = read_sigcontext_register (frame->next, IA64_BSP_REGNUM);
1498       cfm = read_sigcontext_register (frame->next, IA64_CFM_REGNUM);
1499     }
1500   else if (next_frame_is_call_dummy)
1501     {
1502       bsp = deprecated_read_register_dummy (get_frame_pc (frame->next),
1503                                             frame->next->frame,
1504                                             IA64_BSP_REGNUM);
1505       cfm = deprecated_read_register_dummy (get_frame_pc (frame->next),
1506                                             frame->next->frame,
1507                                             IA64_CFM_REGNUM);
1508     }
1509   else
1510     {
1511       struct frame_info *frn = frame->next;
1512
1513       FRAME_INIT_SAVED_REGS (frn);
1514
1515       if (get_frame_saved_regs (frn)[IA64_CFM_REGNUM] != 0)
1516         cfm = read_memory_integer (get_frame_saved_regs (frn)[IA64_CFM_REGNUM], 8);
1517       else if (frn->next && (get_frame_type (frn->next) == SIGTRAMP_FRAME))
1518         cfm = read_sigcontext_register (frn->next, IA64_PFS_REGNUM);
1519       else if (frn->next
1520                && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frn->next), frn->next->frame,
1521                                                    frn->next->frame))
1522         cfm = deprecated_read_register_dummy (get_frame_pc (frn->next), frn->next->frame,
1523                                               IA64_PFS_REGNUM);
1524       else
1525         cfm = read_register (IA64_PFS_REGNUM);
1526
1527       bsp = frn->extra_info->bsp;
1528     }
1529   frame->extra_info->cfm = cfm;
1530   frame->extra_info->sof = cfm & 0x7f;
1531   frame->extra_info->sol = (cfm >> 7) & 0x7f;
1532   if (frame->next == 0
1533       || (get_frame_type (frame->next) == SIGTRAMP_FRAME)
1534       || next_frame_is_call_dummy)
1535     frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sof);
1536   else
1537     frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sol);
1538
1539   frame->extra_info->after_prologue = 0;
1540   frame->extra_info->mem_stack_frame_size = -1;         /* Not yet determined */
1541   frame->extra_info->fp_reg = 0;
1542 }
1543
1544 static int
1545 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
1546 {
1547   switch (TYPE_CODE (t))
1548     {
1549     case TYPE_CODE_FLT:
1550       if (*etp)
1551         return TYPE_LENGTH (*etp) == TYPE_LENGTH (t);
1552       else
1553         {
1554           *etp = t;
1555           return 1;
1556         }
1557       break;
1558     case TYPE_CODE_ARRAY:
1559       return
1560         is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t)),
1561                                       etp);
1562       break;
1563     case TYPE_CODE_STRUCT:
1564       {
1565         int i;
1566
1567         for (i = 0; i < TYPE_NFIELDS (t); i++)
1568           if (!is_float_or_hfa_type_recurse
1569               (check_typedef (TYPE_FIELD_TYPE (t, i)), etp))
1570             return 0;
1571         return 1;
1572       }
1573       break;
1574     default:
1575       return 0;
1576       break;
1577     }
1578 }
1579
1580 /* Determine if the given type is one of the floating point types or
1581    and HFA (which is a struct, array, or combination thereof whose
1582    bottom-most elements are all of the same floating point type.) */
1583
1584 static struct type *
1585 is_float_or_hfa_type (struct type *t)
1586 {
1587   struct type *et = 0;
1588
1589   return is_float_or_hfa_type_recurse (t, &et) ? et : 0;
1590 }
1591
1592
1593 /* Return 1 if the alignment of T is such that the next even slot
1594    should be used.  Return 0, if the next available slot should
1595    be used.  (See section 8.5.1 of the IA-64 Software Conventions
1596    and Runtime manual.)  */
1597
1598 static int
1599 slot_alignment_is_next_even (struct type *t)
1600 {
1601   switch (TYPE_CODE (t))
1602     {
1603     case TYPE_CODE_INT:
1604     case TYPE_CODE_FLT:
1605       if (TYPE_LENGTH (t) > 8)
1606         return 1;
1607       else
1608         return 0;
1609     case TYPE_CODE_ARRAY:
1610       return
1611         slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t)));
1612     case TYPE_CODE_STRUCT:
1613       {
1614         int i;
1615
1616         for (i = 0; i < TYPE_NFIELDS (t); i++)
1617           if (slot_alignment_is_next_even
1618               (check_typedef (TYPE_FIELD_TYPE (t, i))))
1619             return 1;
1620         return 0;
1621       }
1622     default:
1623       return 0;
1624     }
1625 }
1626
1627 /* Attempt to find (and return) the global pointer for the given
1628    function.
1629
1630    This is a rather nasty bit of code searchs for the .dynamic section
1631    in the objfile corresponding to the pc of the function we're trying
1632    to call.  Once it finds the addresses at which the .dynamic section
1633    lives in the child process, it scans the Elf64_Dyn entries for a
1634    DT_PLTGOT tag.  If it finds one of these, the corresponding
1635    d_un.d_ptr value is the global pointer.  */
1636
1637 static CORE_ADDR
1638 generic_elf_find_global_pointer (CORE_ADDR faddr)
1639 {
1640   struct obj_section *faddr_sect;
1641
1642   faddr_sect = find_pc_section (faddr);
1643   if (faddr_sect != NULL)
1644     {
1645       struct obj_section *osect;
1646
1647       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1648         {
1649           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
1650             break;
1651         }
1652
1653       if (osect < faddr_sect->objfile->sections_end)
1654         {
1655           CORE_ADDR addr;
1656
1657           addr = osect->addr;
1658           while (addr < osect->endaddr)
1659             {
1660               int status;
1661               LONGEST tag;
1662               char buf[8];
1663
1664               status = target_read_memory (addr, buf, sizeof (buf));
1665               if (status != 0)
1666                 break;
1667               tag = extract_signed_integer (buf, sizeof (buf));
1668
1669               if (tag == DT_PLTGOT)
1670                 {
1671                   CORE_ADDR global_pointer;
1672
1673                   status = target_read_memory (addr + 8, buf, sizeof (buf));
1674                   if (status != 0)
1675                     break;
1676                   global_pointer = extract_address (buf, sizeof (buf));
1677
1678                   /* The payoff... */
1679                   return global_pointer;
1680                 }
1681
1682               if (tag == DT_NULL)
1683                 break;
1684
1685               addr += 16;
1686             }
1687         }
1688     }
1689   return 0;
1690 }
1691
1692 /* Given a function's address, attempt to find (and return) the
1693    corresponding (canonical) function descriptor.  Return 0 if
1694    not found. */
1695 static CORE_ADDR
1696 find_extant_func_descr (CORE_ADDR faddr)
1697 {
1698   struct obj_section *faddr_sect;
1699
1700   /* Return early if faddr is already a function descriptor */
1701   faddr_sect = find_pc_section (faddr);
1702   if (faddr_sect && strcmp (faddr_sect->the_bfd_section->name, ".opd") == 0)
1703     return faddr;
1704
1705   if (faddr_sect != NULL)
1706     {
1707       struct obj_section *osect;
1708       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1709         {
1710           if (strcmp (osect->the_bfd_section->name, ".opd") == 0)
1711             break;
1712         }
1713
1714       if (osect < faddr_sect->objfile->sections_end)
1715         {
1716           CORE_ADDR addr;
1717
1718           addr = osect->addr;
1719           while (addr < osect->endaddr)
1720             {
1721               int status;
1722               LONGEST faddr2;
1723               char buf[8];
1724
1725               status = target_read_memory (addr, buf, sizeof (buf));
1726               if (status != 0)
1727                 break;
1728               faddr2 = extract_signed_integer (buf, sizeof (buf));
1729
1730               if (faddr == faddr2)
1731                 return addr;
1732
1733               addr += 16;
1734             }
1735         }
1736     }
1737   return 0;
1738 }
1739
1740 /* Attempt to find a function descriptor corresponding to the
1741    given address.  If none is found, construct one on the
1742    stack using the address at fdaptr */
1743
1744 static CORE_ADDR
1745 find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
1746 {
1747   CORE_ADDR fdesc;
1748
1749   fdesc = find_extant_func_descr (faddr);
1750
1751   if (fdesc == 0)
1752     {
1753       CORE_ADDR global_pointer;
1754       char buf[16];
1755
1756       fdesc = *fdaptr;
1757       *fdaptr += 16;
1758
1759       global_pointer = FIND_GLOBAL_POINTER (faddr);
1760
1761       if (global_pointer == 0)
1762         global_pointer = read_register (IA64_GR1_REGNUM);
1763
1764       store_address (buf, 8, faddr);
1765       store_address (buf + 8, 8, global_pointer);
1766
1767       write_memory (fdesc, buf, 16);
1768     }
1769
1770   return fdesc;
1771 }
1772
1773 CORE_ADDR
1774 ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1775                     int struct_return, CORE_ADDR struct_addr)
1776 {
1777   int argno;
1778   struct value *arg;
1779   struct type *type;
1780   int len, argoffset;
1781   int nslots, rseslots, memslots, slotnum, nfuncargs;
1782   int floatreg;
1783   CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr;
1784
1785   nslots = 0;
1786   nfuncargs = 0;
1787   /* Count the number of slots needed for the arguments */
1788   for (argno = 0; argno < nargs; argno++)
1789     {
1790       arg = args[argno];
1791       type = check_typedef (VALUE_TYPE (arg));
1792       len = TYPE_LENGTH (type);
1793
1794       if ((nslots & 1) && slot_alignment_is_next_even (type))
1795         nslots++;
1796
1797       if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1798         nfuncargs++;
1799
1800       nslots += (len + 7) / 8;
1801     }
1802
1803   /* Divvy up the slots between the RSE and the memory stack */
1804   rseslots = (nslots > 8) ? 8 : nslots;
1805   memslots = nslots - rseslots;
1806
1807   /* Allocate a new RSE frame */
1808   cfm = read_register (IA64_CFM_REGNUM);
1809
1810   bsp = read_register (IA64_BSP_REGNUM);
1811   bsp = rse_address_add (bsp, cfm & 0x7f);
1812   new_bsp = rse_address_add (bsp, rseslots);
1813   write_register (IA64_BSP_REGNUM, new_bsp);
1814
1815   pfs = read_register (IA64_PFS_REGNUM);
1816   pfs &= 0xc000000000000000LL;
1817   pfs |= (cfm & 0xffffffffffffLL);
1818   write_register (IA64_PFS_REGNUM, pfs);
1819
1820   cfm &= 0xc000000000000000LL;
1821   cfm |= rseslots;
1822   write_register (IA64_CFM_REGNUM, cfm);
1823
1824   /* We will attempt to find function descriptors in the .opd segment,
1825      but if we can't we'll construct them ourselves.  That being the
1826      case, we'll need to reserve space on the stack for them. */
1827   funcdescaddr = sp - nfuncargs * 16;
1828   funcdescaddr &= ~0xfLL;
1829
1830   /* Adjust the stack pointer to it's new value.  The calling conventions
1831      require us to have 16 bytes of scratch, plus whatever space is
1832      necessary for the memory slots and our function descriptors */
1833   sp = sp - 16 - (memslots + nfuncargs) * 8;
1834   sp &= ~0xfLL;                         /* Maintain 16 byte alignment */
1835
1836   /* Place the arguments where they belong.  The arguments will be
1837      either placed in the RSE backing store or on the memory stack.
1838      In addition, floating point arguments or HFAs are placed in
1839      floating point registers. */
1840   slotnum = 0;
1841   floatreg = IA64_FR8_REGNUM;
1842   for (argno = 0; argno < nargs; argno++)
1843     {
1844       struct type *float_elt_type;
1845
1846       arg = args[argno];
1847       type = check_typedef (VALUE_TYPE (arg));
1848       len = TYPE_LENGTH (type);
1849
1850       /* Special handling for function parameters */
1851       if (len == 8
1852           && TYPE_CODE (type) == TYPE_CODE_PTR
1853           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1854         {
1855           char val_buf[8];
1856
1857           store_address (val_buf, 8,
1858             find_func_descr (extract_address (VALUE_CONTENTS (arg), 8),
1859                              &funcdescaddr));
1860           if (slotnum < rseslots)
1861             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1862           else
1863             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1864           slotnum++;
1865           continue;
1866         }
1867
1868       /* Normal slots */
1869
1870       /* Skip odd slot if necessary...  */
1871       if ((slotnum & 1) && slot_alignment_is_next_even (type))
1872         slotnum++;
1873
1874       argoffset = 0;
1875       while (len > 0)
1876         {
1877           char val_buf[8];
1878
1879           memset (val_buf, 0, 8);
1880           memcpy (val_buf, VALUE_CONTENTS (arg) + argoffset, (len > 8) ? 8 : len);
1881
1882           if (slotnum < rseslots)
1883             write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1884           else
1885             write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1886
1887           argoffset += 8;
1888           len -= 8;
1889           slotnum++;
1890         }
1891
1892       /* Handle floating point types (including HFAs) */
1893       float_elt_type = is_float_or_hfa_type (type);
1894       if (float_elt_type != NULL)
1895         {
1896           argoffset = 0;
1897           len = TYPE_LENGTH (type);
1898           while (len > 0 && floatreg < IA64_FR16_REGNUM)
1899             {
1900               ia64_register_convert_to_raw (
1901                 float_elt_type,
1902                 floatreg,
1903                 VALUE_CONTENTS (arg) + argoffset,
1904                 &deprecated_registers[REGISTER_BYTE (floatreg)]);
1905               floatreg++;
1906               argoffset += TYPE_LENGTH (float_elt_type);
1907               len -= TYPE_LENGTH (float_elt_type);
1908             }
1909         }
1910     }
1911
1912   /* Store the struct return value in r8 if necessary. */
1913   if (struct_return)
1914     {
1915       store_address (&deprecated_registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
1916                      REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
1917                      struct_addr);
1918     }
1919
1920   /* Sync gdb's idea of what the registers are with the target. */
1921   target_store_registers (-1);
1922
1923   /* FIXME: This doesn't belong here!  Instead, SAVE_DUMMY_FRAME_TOS needs
1924      to be defined to call generic_save_dummy_frame_tos().  But at the
1925      time of this writing, SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so
1926      I chose to put this call here instead of using the old mechanisms.
1927      Once SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do is add the
1928      line
1929
1930         set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1931
1932      to ia64_gdbarch_init() and remove the line below. */
1933   generic_save_dummy_frame_tos (sp);
1934
1935   return sp;
1936 }
1937
1938 CORE_ADDR
1939 ia64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1940 {
1941   CORE_ADDR global_pointer = FIND_GLOBAL_POINTER (pc);
1942
1943   if (global_pointer != 0)
1944     write_register (IA64_GR1_REGNUM, global_pointer);
1945
1946   write_register (IA64_BR0_REGNUM, CALL_DUMMY_ADDRESS ());
1947   return sp;
1948 }
1949
1950 void
1951 ia64_store_return_value (struct type *type, char *valbuf)
1952 {
1953   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1954     {
1955       ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
1956                                     &deprecated_registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
1957       target_store_registers (IA64_FR8_REGNUM);
1958     }
1959   else
1960     deprecated_write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
1961                                      valbuf, TYPE_LENGTH (type));
1962 }
1963
1964 void
1965 ia64_pop_frame (void)
1966 {
1967   generic_pop_current_frame (ia64_pop_frame_regular);
1968 }
1969
1970 static void
1971 ia64_pop_frame_regular (struct frame_info *frame)
1972 {
1973   int regno;
1974   CORE_ADDR bsp, cfm, pfs;
1975
1976   FRAME_INIT_SAVED_REGS (frame);
1977
1978   for (regno = 0; regno < ia64_num_regs; regno++)
1979     {
1980       if (get_frame_saved_regs (frame)[regno]
1981           && (!(IA64_GR32_REGNUM <= regno && regno <= IA64_GR127_REGNUM))
1982           && regno != pc_regnum
1983           && regno != sp_regnum
1984           && regno != IA64_PFS_REGNUM
1985           && regno != IA64_CFM_REGNUM
1986           && regno != IA64_BSP_REGNUM
1987           && regno != IA64_BSPSTORE_REGNUM)
1988         {
1989           write_register (regno,
1990                           read_memory_integer (get_frame_saved_regs (frame)[regno],
1991                                                REGISTER_RAW_SIZE (regno)));
1992         }
1993     }
1994
1995   write_register (sp_regnum, FRAME_CHAIN (frame));
1996   write_pc (FRAME_SAVED_PC (frame));
1997
1998   cfm = read_register (IA64_CFM_REGNUM);
1999
2000   if (get_frame_saved_regs (frame)[IA64_PFS_REGNUM])
2001     {
2002       pfs = read_memory_integer (get_frame_saved_regs (frame)[IA64_PFS_REGNUM],
2003                                  REGISTER_RAW_SIZE (IA64_PFS_REGNUM));
2004     }
2005   else
2006     pfs = read_register (IA64_PFS_REGNUM);
2007
2008   /* Compute the new bsp by *adding* the difference between the
2009      size of the frame and the size of the locals (both wrt the
2010      frame that we're going back to).  This seems kind of strange,
2011      especially since it seems like we ought to be subtracting the
2012      size of the locals... and we should; but the Linux kernel
2013      wants bsp to be set at the end of all used registers.  It's
2014      likely that this code will need to be revised to accomodate
2015      other operating systems. */
2016   bsp = rse_address_add (frame->extra_info->bsp,
2017                          (pfs & 0x7f) - ((pfs >> 7) & 0x7f));
2018   write_register (IA64_BSP_REGNUM, bsp);
2019
2020   /* FIXME: What becomes of the epilog count in the PFS? */
2021   cfm = (cfm & ~0xffffffffffffLL) | (pfs & 0xffffffffffffLL);
2022   write_register (IA64_CFM_REGNUM, cfm);
2023
2024   flush_cached_frames ();
2025 }
2026
2027 static void
2028 ia64_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
2029                                     CORE_ADDR *targ_addr, int *targ_len)
2030 {
2031   *targ_addr = memaddr;
2032   *targ_len  = nr_bytes;
2033 }
2034
2035 static void
2036 process_note_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
2037 {
2038   int *os_ident_ptr = obj;
2039   const char *name;
2040   unsigned int sectsize;
2041
2042   name = bfd_get_section_name (abfd, sect);
2043   sectsize = bfd_section_size (abfd, sect);
2044   if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
2045     {
2046       unsigned int name_length, data_length, note_type;
2047       char *note = alloca (sectsize);
2048
2049       bfd_get_section_contents (abfd, sect, note,
2050                                 (file_ptr) 0, (bfd_size_type) sectsize);
2051
2052       name_length = bfd_h_get_32 (abfd, note);
2053       data_length = bfd_h_get_32 (abfd, note + 4);
2054       note_type   = bfd_h_get_32 (abfd, note + 8);
2055
2056       if (name_length == 4 && data_length == 16 && note_type == 1
2057           && strcmp (note + 12, "GNU") == 0)
2058         {
2059           int os_number = bfd_h_get_32 (abfd, note + 16);
2060
2061           /* The case numbers are from abi-tags in glibc */
2062           switch (os_number)
2063             {
2064             case 0 :
2065               *os_ident_ptr = ELFOSABI_LINUX;
2066               break;
2067             case 1 :
2068               *os_ident_ptr = ELFOSABI_HURD;
2069               break;
2070             case 2 :
2071               *os_ident_ptr = ELFOSABI_SOLARIS;
2072               break;
2073             default :
2074               internal_error (__FILE__, __LINE__,
2075                               "process_note_abi_sections: unknown OS number %d", os_number);
2076               break;
2077             }
2078         }
2079     }
2080 }
2081
2082 static struct gdbarch *
2083 ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2084 {
2085   struct gdbarch *gdbarch;
2086   struct gdbarch_tdep *tdep;
2087   int os_ident;
2088
2089   if (info.abfd != NULL
2090       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2091     {
2092       os_ident = elf_elfheader (info.abfd)->e_ident[EI_OSABI];
2093
2094       /* If os_ident is 0, it is not necessarily the case that we're
2095          on a SYSV system.  (ELFOSABI_NONE is defined to be 0.)
2096          GNU/Linux uses a note section to record OS/ABI info, but
2097          leaves e_ident[EI_OSABI] zero.  So we have to check for note
2098          sections too. */
2099       if (os_ident == 0)
2100         {
2101           bfd_map_over_sections (info.abfd,
2102                                  process_note_abi_tag_sections,
2103                                  &os_ident);
2104         }
2105     }
2106   else
2107     os_ident = -1;
2108
2109   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2110        arches != NULL;
2111        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2112     {
2113       tdep = gdbarch_tdep (arches->gdbarch);
2114       if (tdep &&tdep->os_ident == os_ident)
2115         return arches->gdbarch;
2116     }
2117
2118   tdep = xmalloc (sizeof (struct gdbarch_tdep));
2119   gdbarch = gdbarch_alloc (&info, tdep);
2120   tdep->os_ident = os_ident;
2121
2122   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2123      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
2124   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
2125
2126   /* Set the method of obtaining the sigcontext addresses at which
2127      registers are saved.  The method of checking to see if
2128      native_find_global_pointer is nonzero to indicate that we're
2129      on AIX is kind of hokey, but I can't think of a better way
2130      to do it.  */
2131   if (os_ident == ELFOSABI_LINUX)
2132     tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
2133   else if (native_find_global_pointer != 0)
2134     tdep->sigcontext_register_address = ia64_aix_sigcontext_register_address;
2135   else
2136     tdep->sigcontext_register_address = 0;
2137
2138   /* We know that GNU/Linux won't have to resort to the
2139      native_find_global_pointer hackery.  But that's the only one we
2140      know about so far, so if native_find_global_pointer is set to
2141      something non-zero, then use it.  Otherwise fall back to using
2142      generic_elf_find_global_pointer.  This arrangement should (in
2143      theory) allow us to cross debug GNU/Linux binaries from an AIX
2144      machine.  */
2145   if (os_ident == ELFOSABI_LINUX)
2146     tdep->find_global_pointer = generic_elf_find_global_pointer;
2147   else if (native_find_global_pointer != 0)
2148     tdep->find_global_pointer = native_find_global_pointer;
2149   else
2150     tdep->find_global_pointer = generic_elf_find_global_pointer;
2151
2152   set_gdbarch_short_bit (gdbarch, 16);
2153   set_gdbarch_int_bit (gdbarch, 32);
2154   set_gdbarch_long_bit (gdbarch, 64);
2155   set_gdbarch_long_long_bit (gdbarch, 64);
2156   set_gdbarch_float_bit (gdbarch, 32);
2157   set_gdbarch_double_bit (gdbarch, 64);
2158   set_gdbarch_long_double_bit (gdbarch, 64);
2159   set_gdbarch_ptr_bit (gdbarch, 64);
2160
2161   set_gdbarch_num_regs (gdbarch, ia64_num_regs);
2162   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
2163   set_gdbarch_fp_regnum (gdbarch, fp_regnum);
2164   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
2165   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
2166
2167   set_gdbarch_register_name (gdbarch, ia64_register_name);
2168   set_gdbarch_register_size (gdbarch, 8);
2169   set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
2170   set_gdbarch_register_byte (gdbarch, ia64_register_byte);
2171   set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
2172   set_gdbarch_max_register_raw_size (gdbarch, 16);
2173   set_gdbarch_register_virtual_size (gdbarch, ia64_register_virtual_size);
2174   set_gdbarch_max_register_virtual_size (gdbarch, 16);
2175   set_gdbarch_register_virtual_type (gdbarch, ia64_register_virtual_type);
2176
2177   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
2178
2179   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
2180   set_gdbarch_frameless_function_invocation (gdbarch, ia64_frameless_function_invocation);
2181
2182   set_gdbarch_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
2183
2184   set_gdbarch_frame_chain (gdbarch, ia64_frame_chain);
2185   set_gdbarch_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
2186
2187   set_gdbarch_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
2188   set_gdbarch_get_saved_register (gdbarch, ia64_get_saved_register);
2189
2190   set_gdbarch_register_convertible (gdbarch, ia64_register_convertible);
2191   set_gdbarch_register_convert_to_virtual (gdbarch, ia64_register_convert_to_virtual);
2192   set_gdbarch_register_convert_to_raw (gdbarch, ia64_register_convert_to_raw);
2193
2194   set_gdbarch_use_struct_convention (gdbarch, ia64_use_struct_convention);
2195   set_gdbarch_deprecated_extract_return_value (gdbarch, ia64_extract_return_value);
2196
2197   set_gdbarch_store_struct_return (gdbarch, ia64_store_struct_return);
2198   set_gdbarch_deprecated_store_return_value (gdbarch, ia64_store_return_value);
2199   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
2200
2201   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
2202   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
2203   set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc);
2204   set_gdbarch_read_pc (gdbarch, ia64_read_pc);
2205   set_gdbarch_write_pc (gdbarch, ia64_write_pc);
2206
2207   /* Settings for calling functions in the inferior.  */
2208   set_gdbarch_call_dummy_length (gdbarch, 0);
2209   set_gdbarch_push_arguments (gdbarch, ia64_push_arguments);
2210   set_gdbarch_push_return_address (gdbarch, ia64_push_return_address);
2211   set_gdbarch_pop_frame (gdbarch, ia64_pop_frame);
2212
2213   set_gdbarch_call_dummy_p (gdbarch, 1);
2214   set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
2215   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
2216   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
2217   set_gdbarch_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
2218   set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
2219   set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
2220
2221   /* We won't necessarily have a frame pointer and even if we do,
2222      it winds up being extraordinarly messy when attempting to find
2223      the frame chain.  So for the purposes of creating frames (which
2224      is all read_fp() is used for), simply use the stack pointer value
2225      instead.  */
2226   set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
2227
2228   /* Settings that should be unnecessary.  */
2229   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2230
2231   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
2232   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
2233
2234   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
2235   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
2236   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
2237   set_gdbarch_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 }