1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
3 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
24 #include "symfile.h" /* for entry_point_address */
26 #include "arch-utils.h"
27 #include "floatformat.h"
33 #include "elf/common.h" /* for DT_PLTGOT value */
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.
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. */
45 CORE_ADDR (*native_find_global_pointer) (CORE_ADDR) = 0;
47 /* An enumeration of the different IA-64 instruction types. */
49 typedef enum instruction_type
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 */
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.
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. */
76 #define SLOT_MULTIPLIER 1
78 /* Length in bytes of an instruction bundle */
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);
86 static gdbarch_init_ftype ia64_gdbarch_init;
88 static gdbarch_register_name_ftype ia64_register_name;
89 static gdbarch_register_raw_size_ftype ia64_register_raw_size;
90 static gdbarch_register_virtual_size_ftype ia64_register_virtual_size;
91 static gdbarch_register_virtual_type_ftype ia64_register_virtual_type;
92 static gdbarch_register_byte_ftype ia64_register_byte;
93 static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc;
94 static gdbarch_frame_chain_ftype ia64_frame_chain;
95 static gdbarch_frame_saved_pc_ftype ia64_frame_saved_pc;
96 static gdbarch_skip_prologue_ftype ia64_skip_prologue;
97 static gdbarch_frame_init_saved_regs_ftype ia64_frame_init_saved_regs;
98 static gdbarch_get_saved_register_ftype ia64_get_saved_register;
99 static gdbarch_extract_return_value_ftype ia64_extract_return_value;
100 static gdbarch_extract_struct_value_address_ftype ia64_extract_struct_value_address;
101 static gdbarch_use_struct_convention_ftype ia64_use_struct_convention;
102 static gdbarch_frameless_function_invocation_ftype ia64_frameless_function_invocation;
103 static gdbarch_init_extra_frame_info_ftype ia64_init_extra_frame_info;
104 static gdbarch_store_return_value_ftype ia64_store_return_value;
105 static gdbarch_store_struct_return_ftype ia64_store_struct_return;
106 static gdbarch_push_arguments_ftype ia64_push_arguments;
107 static gdbarch_push_return_address_ftype ia64_push_return_address;
108 static gdbarch_pop_frame_ftype ia64_pop_frame;
109 static gdbarch_saved_pc_after_call_ftype ia64_saved_pc_after_call;
110 static void ia64_pop_frame_regular (struct frame_info *frame);
111 static struct type *is_float_or_hfa_type (struct type *t);
113 static int ia64_num_regs = 590;
115 static int pc_regnum = IA64_IP_REGNUM;
116 static int sp_regnum = IA64_GR12_REGNUM;
117 static int fp_regnum = IA64_VFP_REGNUM;
118 static int lr_regnum = IA64_VRAP_REGNUM;
120 static LONGEST ia64_call_dummy_words[] = {0};
122 /* Array of register names; There should be ia64_num_regs strings in
125 static char *ia64_register_names[] =
126 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
127 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
128 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
129 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
130 "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
131 "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
132 "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
133 "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
134 "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
135 "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
136 "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
137 "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
138 "r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
139 "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
140 "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
141 "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
143 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
144 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
145 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
146 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
147 "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
148 "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47",
149 "f48", "f49", "f50", "f51", "f52", "f53", "f54", "f55",
150 "f56", "f57", "f58", "f59", "f60", "f61", "f62", "f63",
151 "f64", "f65", "f66", "f67", "f68", "f69", "f70", "f71",
152 "f72", "f73", "f74", "f75", "f76", "f77", "f78", "f79",
153 "f80", "f81", "f82", "f83", "f84", "f85", "f86", "f87",
154 "f88", "f89", "f90", "f91", "f92", "f93", "f94", "f95",
155 "f96", "f97", "f98", "f99", "f100", "f101", "f102", "f103",
156 "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
157 "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
158 "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
160 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
161 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
162 "p16", "p17", "p18", "p19", "p20", "p21", "p22", "p23",
163 "p24", "p25", "p26", "p27", "p28", "p29", "p30", "p31",
164 "p32", "p33", "p34", "p35", "p36", "p37", "p38", "p39",
165 "p40", "p41", "p42", "p43", "p44", "p45", "p46", "p47",
166 "p48", "p49", "p50", "p51", "p52", "p53", "p54", "p55",
167 "p56", "p57", "p58", "p59", "p60", "p61", "p62", "p63",
169 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
173 "pr", "ip", "psr", "cfm",
175 "kr0", "kr1", "kr2", "kr3", "kr4", "kr5", "kr6", "kr7",
176 "", "", "", "", "", "", "", "",
177 "rsc", "bsp", "bspstore", "rnat",
179 "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr", "",
180 "ccv", "", "", "", "unat", "", "", "",
181 "fpsr", "", "", "", "itc",
182 "", "", "", "", "", "", "", "", "", "",
183 "", "", "", "", "", "", "", "", "",
185 "", "", "", "", "", "", "", "", "", "",
186 "", "", "", "", "", "", "", "", "", "",
187 "", "", "", "", "", "", "", "", "", "",
188 "", "", "", "", "", "", "", "", "", "",
189 "", "", "", "", "", "", "", "", "", "",
190 "", "", "", "", "", "", "", "", "", "",
192 "nat0", "nat1", "nat2", "nat3", "nat4", "nat5", "nat6", "nat7",
193 "nat8", "nat9", "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
194 "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
195 "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
196 "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
197 "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
198 "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
199 "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
200 "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
201 "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
202 "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
203 "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
204 "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
205 "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
206 "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
207 "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
210 struct frame_extra_info
212 CORE_ADDR bsp; /* points at r32 for the current frame */
213 CORE_ADDR cfm; /* cfm value for current frame */
214 int sof; /* Size of frame (decoded from cfm value) */
215 int sol; /* Size of locals (decoded from cfm value) */
216 CORE_ADDR after_prologue;
217 /* Address of first instruction after the last
218 prologue instruction; Note that there may
219 be instructions from the function's body
220 intermingled with the prologue. */
221 int mem_stack_frame_size;
222 /* Size of the memory stack frame (may be zero),
223 or -1 if it has not been determined yet. */
224 int fp_reg; /* Register number (if any) used a frame pointer
225 for this frame. 0 if no register is being used
226 as the frame pointer. */
231 int os_ident; /* From the ELF header, one of the ELFOSABI_
232 constants: ELFOSABI_LINUX, ELFOSABI_AIX,
234 CORE_ADDR (*sigcontext_register_address) (CORE_ADDR, int);
235 /* OS specific function which, given a frame address
236 and register number, returns the offset to the
237 given register from the start of the frame. */
238 CORE_ADDR (*find_global_pointer) (CORE_ADDR);
241 #define SIGCONTEXT_REGISTER_ADDRESS \
242 (gdbarch_tdep (current_gdbarch)->sigcontext_register_address)
243 #define FIND_GLOBAL_POINTER \
244 (gdbarch_tdep (current_gdbarch)->find_global_pointer)
247 ia64_register_name (int reg)
249 return ia64_register_names[reg];
253 ia64_register_raw_size (int reg)
255 return (IA64_FR0_REGNUM <= reg && reg <= IA64_FR127_REGNUM) ? 16 : 8;
259 ia64_register_virtual_size (int reg)
261 return (IA64_FR0_REGNUM <= reg && reg <= IA64_FR127_REGNUM) ? 16 : 8;
264 /* Return true iff register N's virtual format is different from
267 ia64_register_convertible (int nr)
269 return (IA64_FR0_REGNUM <= nr && nr <= IA64_FR127_REGNUM);
272 const struct floatformat floatformat_ia64_ext =
274 floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
275 floatformat_intbit_yes
279 ia64_register_convert_to_virtual (int regnum, struct type *type,
280 char *from, char *to)
282 if (regnum >= IA64_FR0_REGNUM && regnum <= IA64_FR127_REGNUM)
285 floatformat_to_doublest (&floatformat_ia64_ext, from, &val);
286 store_floating(to, TYPE_LENGTH(type), val);
289 error("ia64_register_convert_to_virtual called with non floating point register number");
293 ia64_register_convert_to_raw (struct type *type, int regnum,
294 char *from, char *to)
296 if (regnum >= IA64_FR0_REGNUM && regnum <= IA64_FR127_REGNUM)
298 DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
299 floatformat_from_doublest (&floatformat_ia64_ext, &val, to);
302 error("ia64_register_convert_to_raw called with non floating point register number");
306 ia64_register_virtual_type (int reg)
308 if (reg >= IA64_FR0_REGNUM && reg <= IA64_FR127_REGNUM)
309 return builtin_type_long_double;
311 return builtin_type_long;
315 ia64_register_byte (int reg)
318 (reg <= IA64_FR0_REGNUM ? 0 : 8 * ((reg > IA64_FR127_REGNUM) ? 128 : reg - IA64_FR0_REGNUM));
321 /* Read the given register from a sigcontext structure in the
325 read_sigcontext_register (struct frame_info *frame, int regnum)
330 internal_error (__FILE__, __LINE__,
331 "read_sigcontext_register: NULL frame");
332 if (!frame->signal_handler_caller)
333 internal_error (__FILE__, __LINE__,
334 "read_sigcontext_register: frame not a signal_handler_caller");
335 if (SIGCONTEXT_REGISTER_ADDRESS == 0)
336 internal_error (__FILE__, __LINE__,
337 "read_sigcontext_register: SIGCONTEXT_REGISTER_ADDRESS is 0");
339 regaddr = SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regnum);
341 return read_memory_integer (regaddr, REGISTER_RAW_SIZE (regnum));
343 internal_error (__FILE__, __LINE__,
344 "read_sigcontext_register: Register %d not in struct sigcontext", regnum);
347 /* Extract ``len'' bits from an instruction bundle starting at
351 extract_bit_field (char *bundle, int from, int len)
353 long long result = 0LL;
355 int from_byte = from / 8;
356 int to_byte = to / 8;
357 unsigned char *b = (unsigned char *) bundle;
363 if (from_byte == to_byte)
364 c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
365 result = c >> (from % 8);
366 lshift = 8 - (from % 8);
368 for (i = from_byte+1; i < to_byte; i++)
370 result |= ((long long) b[i]) << lshift;
374 if (from_byte < to_byte && (to % 8 != 0))
377 c = ((unsigned char) (c << (8 - to % 8))) >> (8 - to % 8);
378 result |= ((long long) c) << lshift;
384 /* Replace the specified bits in an instruction bundle */
387 replace_bit_field (char *bundle, long long val, int from, int len)
390 int from_byte = from / 8;
391 int to_byte = to / 8;
392 unsigned char *b = (unsigned char *) bundle;
395 if (from_byte == to_byte)
397 unsigned char left, right;
399 left = (c >> (to % 8)) << (to % 8);
400 right = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
401 c = (unsigned char) (val & 0xff);
402 c = (unsigned char) (c << (from % 8 + 8 - to % 8)) >> (8 - to % 8);
410 c = ((unsigned char) (c << (8 - from % 8))) >> (8 - from % 8);
411 c = c | (val << (from % 8));
413 val >>= 8 - from % 8;
415 for (i = from_byte+1; i < to_byte; i++)
424 unsigned char cv = (unsigned char) val;
426 c = c >> (to % 8) << (to % 8);
427 c |= ((unsigned char) (cv << (8 - to % 8))) >> (8 - to % 8);
433 /* Return the contents of slot N (for N = 0, 1, or 2) in
434 and instruction bundle */
437 slotN_contents (char *bundle, int slotnum)
439 return extract_bit_field (bundle, 5+41*slotnum, 41);
442 /* Store an instruction in an instruction bundle */
445 replace_slotN_contents (char *bundle, long long instr, int slotnum)
447 replace_bit_field (bundle, instr, 5+41*slotnum, 41);
450 static enum instruction_type template_encoding_table[32][3] =
452 { M, I, I }, /* 00 */
453 { M, I, I }, /* 01 */
454 { M, I, I }, /* 02 */
455 { M, I, I }, /* 03 */
456 { M, L, X }, /* 04 */
457 { M, L, X }, /* 05 */
458 { undefined, undefined, undefined }, /* 06 */
459 { undefined, undefined, undefined }, /* 07 */
460 { M, M, I }, /* 08 */
461 { M, M, I }, /* 09 */
462 { M, M, I }, /* 0A */
463 { M, M, I }, /* 0B */
464 { M, F, I }, /* 0C */
465 { M, F, I }, /* 0D */
466 { M, M, F }, /* 0E */
467 { M, M, F }, /* 0F */
468 { M, I, B }, /* 10 */
469 { M, I, B }, /* 11 */
470 { M, B, B }, /* 12 */
471 { M, B, B }, /* 13 */
472 { undefined, undefined, undefined }, /* 14 */
473 { undefined, undefined, undefined }, /* 15 */
474 { B, B, B }, /* 16 */
475 { B, B, B }, /* 17 */
476 { M, M, B }, /* 18 */
477 { M, M, B }, /* 19 */
478 { undefined, undefined, undefined }, /* 1A */
479 { undefined, undefined, undefined }, /* 1B */
480 { M, F, B }, /* 1C */
481 { M, F, B }, /* 1D */
482 { undefined, undefined, undefined }, /* 1E */
483 { undefined, undefined, undefined }, /* 1F */
486 /* Fetch and (partially) decode an instruction at ADDR and return the
487 address of the next instruction to fetch. */
490 fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr)
492 char bundle[BUNDLE_LEN];
493 int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
497 /* Warn about slot numbers greater than 2. We used to generate
498 an error here on the assumption that the user entered an invalid
499 address. But, sometimes GDB itself requests an invalid address.
500 This can (easily) happen when execution stops in a function for
501 which there are no symbols. The prologue scanner will attempt to
502 find the beginning of the function - if the nearest symbol
503 happens to not be aligned on a bundle boundary (16 bytes), the
504 resulting starting address will cause GDB to think that the slot
507 So we warn about it and set the slot number to zero. It is
508 not necessarily a fatal condition, particularly if debugging
509 at the assembly language level. */
512 warning ("Can't fetch instructions for slot numbers greater than 2.\n"
513 "Using slot 0 instead");
519 val = target_read_memory (addr, bundle, BUNDLE_LEN);
524 *instr = slotN_contents (bundle, slotnum);
525 template = extract_bit_field (bundle, 0, 5);
526 *it = template_encoding_table[(int)template][slotnum];
528 if (slotnum == 2 || (slotnum == 1 && *it == L))
531 addr += (slotnum + 1) * SLOT_MULTIPLIER;
536 /* There are 5 different break instructions (break.i, break.b,
537 break.m, break.f, and break.x), but they all have the same
538 encoding. (The five bit template in the low five bits of the
539 instruction bundle distinguishes one from another.)
541 The runtime architecture manual specifies that break instructions
542 used for debugging purposes must have the upper two bits of the 21
543 bit immediate set to a 0 and a 1 respectively. A breakpoint
544 instruction encodes the most significant bit of its 21 bit
545 immediate at bit 36 of the 41 bit instruction. The penultimate msb
546 is at bit 25 which leads to the pattern below.
548 Originally, I had this set up to do, e.g, a "break.i 0x80000" But
549 it turns out that 0x80000 was used as the syscall break in the early
550 simulators. So I changed the pattern slightly to do "break.i 0x080001"
551 instead. But that didn't work either (I later found out that this
552 pattern was used by the simulator that I was using.) So I ended up
553 using the pattern seen below. */
556 #define BREAKPOINT 0x00002000040LL
558 #define BREAKPOINT 0x00003333300LL
561 ia64_memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
563 char bundle[BUNDLE_LEN];
564 int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
569 error("Can't insert breakpoint for slot numbers greater than 2.");
573 val = target_read_memory (addr, bundle, BUNDLE_LEN);
574 instr = slotN_contents (bundle, slotnum);
575 memcpy(contents_cache, &instr, sizeof(instr));
576 replace_slotN_contents (bundle, BREAKPOINT, slotnum);
578 target_write_memory (addr, bundle, BUNDLE_LEN);
584 ia64_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
586 char bundle[BUNDLE_LEN];
587 int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER;
593 val = target_read_memory (addr, bundle, BUNDLE_LEN);
594 memcpy (&instr, contents_cache, sizeof instr);
595 replace_slotN_contents (bundle, instr, slotnum);
597 target_write_memory (addr, bundle, BUNDLE_LEN);
602 /* We don't really want to use this, but remote.c needs to call it in order
603 to figure out if Z-packets are supported or not. Oh, well. */
605 ia64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
607 static unsigned char breakpoint[] =
608 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
609 *lenptr = sizeof (breakpoint);
617 ia64_read_pc (ptid_t ptid)
619 CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
620 CORE_ADDR pc_value = read_register_pid (IA64_IP_REGNUM, ptid);
621 int slot_num = (psr_value >> 41) & 3;
623 return pc_value | (slot_num * SLOT_MULTIPLIER);
627 ia64_write_pc (CORE_ADDR new_pc, ptid_t ptid)
629 int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
630 CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
631 psr_value &= ~(3LL << 41);
632 psr_value |= (CORE_ADDR)(slot_num & 0x3) << 41;
636 write_register_pid (IA64_PSR_REGNUM, psr_value, ptid);
637 write_register_pid (IA64_IP_REGNUM, new_pc, ptid);
640 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
642 /* Returns the address of the slot that's NSLOTS slots away from
643 the address ADDR. NSLOTS may be positive or negative. */
645 rse_address_add(CORE_ADDR addr, int nslots)
648 int mandatory_nat_slots = nslots / 63;
649 int direction = nslots < 0 ? -1 : 1;
651 new_addr = addr + 8 * (nslots + mandatory_nat_slots);
653 if ((new_addr >> 9) != ((addr + 8 * 64 * mandatory_nat_slots) >> 9))
654 new_addr += 8 * direction;
656 if (IS_NaT_COLLECTION_ADDR(new_addr))
657 new_addr += 8 * direction;
662 /* The IA-64 frame chain is a bit odd. We won't always have a frame
663 pointer, so we use the SP value as the FP for the purpose of
664 creating a frame. There is sometimes a register (not fixed) which
665 is used as a frame pointer. When this register exists, it is not
666 especially hard to determine which one is being used. It isn't
667 even really hard to compute the frame chain, but it can be
668 computationally expensive. So, instead of making life difficult
669 (and slow), we pick a more convenient representation of the frame
670 chain, knowing that we'll have to make some small adjustments
671 in other places. (E.g, note that read_fp() and write_fp() are
672 actually read_sp() and write_sp() below in ia64_gdbarch_init()
675 Okay, so what is the frame chain exactly? It'll be the SP value
676 at the time that the function in question was entered.
678 Note that this *should* actually the frame pointer for the current
679 function! But as I note above, if we were to attempt to find the
680 address of the beginning of the previous frame, we'd waste a lot
681 of cycles for no good reason. So instead, we simply choose to
682 represent the frame chain as the end of the previous frame instead
686 ia64_frame_chain (struct frame_info *frame)
688 if (frame->signal_handler_caller)
689 return read_sigcontext_register (frame, sp_regnum);
690 else if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
694 FRAME_INIT_SAVED_REGS (frame);
695 if (frame->saved_regs[IA64_VFP_REGNUM])
696 return read_memory_integer (frame->saved_regs[IA64_VFP_REGNUM], 8);
698 return frame->frame + frame->extra_info->mem_stack_frame_size;
703 ia64_frame_saved_pc (struct frame_info *frame)
705 if (frame->signal_handler_caller)
706 return read_sigcontext_register (frame, pc_regnum);
707 else if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
708 return generic_read_register_dummy (frame->pc, frame->frame, pc_regnum);
711 FRAME_INIT_SAVED_REGS (frame);
713 if (frame->saved_regs[IA64_VRAP_REGNUM])
714 return read_memory_integer (frame->saved_regs[IA64_VRAP_REGNUM], 8);
715 else if (frame->next && frame->next->signal_handler_caller)
716 return read_sigcontext_register (frame->next, IA64_BR0_REGNUM);
717 else /* either frameless, or not far enough along in the prologue... */
718 return ia64_saved_pc_after_call (frame);
722 /* Limit the number of skipped non-prologue instructions since examining
723 of the prologue is expensive. */
724 static int max_skip_non_prologue_insns = 10;
726 /* Given PC representing the starting address of a function, and
727 LIM_PC which is the (sloppy) limit to which to scan when looking
728 for a prologue, attempt to further refine this limit by using
729 the line data in the symbol table. If successful, a better guess
730 on where the prologue ends is returned, otherwise the previous
731 value of lim_pc is returned. TRUST_LIMIT is a pointer to a flag
732 which will be set to indicate whether the returned limit may be
733 used with no further scanning in the event that the function is
737 refine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc, int *trust_limit)
739 struct symtab_and_line prologue_sal;
740 CORE_ADDR start_pc = pc;
742 /* Start off not trusting the limit. */
745 prologue_sal = find_pc_line (pc, 0);
746 if (prologue_sal.line != 0)
749 CORE_ADDR addr = prologue_sal.end;
751 /* Handle the case in which compiler's optimizer/scheduler
752 has moved instructions into the prologue. We scan ahead
753 in the function looking for address ranges whose corresponding
754 line number is less than or equal to the first one that we
755 found for the function. (It can be less than when the
756 scheduler puts a body instruction before the first prologue
758 for (i = 2 * max_skip_non_prologue_insns;
759 i > 0 && (lim_pc == 0 || addr < lim_pc);
762 struct symtab_and_line sal;
764 sal = find_pc_line (addr, 0);
767 if (sal.line <= prologue_sal.line
768 && sal.symtab == prologue_sal.symtab)
775 if (lim_pc == 0 || prologue_sal.end < lim_pc)
777 lim_pc = prologue_sal.end;
778 if (start_pc == get_pc_function_start (lim_pc))
785 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
786 || (8 <= (_regnum_) && (_regnum_) <= 11) \
787 || (14 <= (_regnum_) && (_regnum_) <= 31))
788 #define imm9(_instr_) \
789 ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
790 | (((_instr_) & 0x00008000000LL) >> 20) \
791 | (((_instr_) & 0x00000001fc0LL) >> 6))
794 examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
797 CORE_ADDR last_prologue_pc = pc;
800 int do_fsr_stuff = 0;
805 int unat_save_reg = 0;
807 int mem_stack_frame_size = 0;
809 CORE_ADDR spill_addr = 0;
814 memset (instores, 0, sizeof instores);
815 memset (infpstores, 0, sizeof infpstores);
817 if (frame && !frame->saved_regs)
819 frame_saved_regs_zalloc (frame);
825 && frame->extra_info->after_prologue != 0
826 && frame->extra_info->after_prologue <= lim_pc)
827 return frame->extra_info->after_prologue;
829 lim_pc = refine_prologue_limit (pc, lim_pc, &trust_limit);
831 /* Must start with an alloc instruction */
832 next_pc = fetch_instruction (pc, &it, &instr);
833 if (pc < lim_pc && next_pc
834 && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL))
837 int sor = (int) ((instr & 0x00078000000LL) >> 27);
838 int sol = (int) ((instr & 0x00007f00000LL) >> 20);
839 int sof = (int) ((instr & 0x000000fe000LL) >> 13);
840 /* Okay, so sor, sol, and sof aren't used right now; but perhaps
841 we could compare against the size given to us via the cfm as
842 either a sanity check or possibly to see if the frame has been
843 changed by a later alloc instruction... */
844 int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
846 last_prologue_pc = next_pc;
851 pc = lim_pc; /* Frameless: We're done early. */
853 last_prologue_pc = lim_pc;
856 /* Loop, looking for prologue instructions, keeping track of
857 where preserved registers were spilled. */
860 next_pc = fetch_instruction (pc, &it, &instr);
864 if ((it == B && ((instr & 0x1e1f800003f) != 0x04000000000))
865 || ((instr & 0x3fLL) != 0LL))
867 /* Exit loop upon hitting a non-nop branch instruction
868 or a predicated instruction. */
871 else if (it == I && ((instr & 0x1eff8000000LL) == 0x00188000000LL))
874 int b2 = (int) ((instr & 0x0000000e000LL) >> 13);
875 int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
876 int qp = (int) (instr & 0x0000000003f);
878 if (qp == 0 && b2 == 0 && rN >= 32 && ret_reg == 0)
881 last_prologue_pc = next_pc;
884 else if ((it == I || it == M)
885 && ((instr & 0x1ee00000000LL) == 0x10800000000LL))
887 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
888 int imm = (int) ((((instr & 0x01000000000LL) ? -1 : 0) << 13)
889 | ((instr & 0x001f8000000LL) >> 20)
890 | ((instr & 0x000000fe000LL) >> 13));
891 int rM = (int) ((instr & 0x00007f00000LL) >> 20);
892 int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
893 int qp = (int) (instr & 0x0000000003fLL);
895 if (qp == 0 && rN >= 32 && imm == 0 && rM == 12 && fp_reg == 0)
899 last_prologue_pc = next_pc;
901 else if (qp == 0 && rN == 12 && rM == 12)
903 /* adds r12, -mem_stack_frame_size, r12 */
904 mem_stack_frame_size -= imm;
905 last_prologue_pc = next_pc;
907 else if (qp == 0 && rN == 2
908 && ((rM == fp_reg && fp_reg != 0) || rM == 12))
910 /* adds r2, spilloffset, rFramePointer
912 adds r2, spilloffset, r12
914 Get ready for stf.spill or st8.spill instructions.
915 The address to start spilling at is loaded into r2.
916 FIXME: Why r2? That's what gcc currently uses; it
917 could well be different for other compilers. */
919 /* Hmm... whether or not this will work will depend on
920 where the pc is. If it's still early in the prologue
921 this'll be wrong. FIXME */
922 spill_addr = (frame ? frame->frame : 0)
923 + (rM == 12 ? 0 : mem_stack_frame_size)
926 last_prologue_pc = next_pc;
930 && ( ((instr & 0x1efc0000000LL) == 0x0eec0000000LL)
931 || ((instr & 0x1ffc8000000LL) == 0x0cec0000000LL) ))
933 /* stf.spill [rN] = fM, imm9
935 stf.spill [rN] = fM */
937 int imm = imm9(instr);
938 int rN = (int) ((instr & 0x00007f00000LL) >> 20);
939 int fM = (int) ((instr & 0x000000fe000LL) >> 13);
940 int qp = (int) (instr & 0x0000000003fLL);
941 if (qp == 0 && rN == spill_reg && spill_addr != 0
942 && ((2 <= fM && fM <= 5) || (16 <= fM && fM <= 31)))
945 frame->saved_regs[IA64_FR0_REGNUM + fM] = spill_addr;
947 if ((instr & 0x1efc0000000) == 0x0eec0000000)
950 spill_addr = 0; /* last one; must be done */
951 last_prologue_pc = next_pc;
954 else if ((it == M && ((instr & 0x1eff8000000LL) == 0x02110000000LL))
955 || (it == I && ((instr & 0x1eff8000000LL) == 0x00050000000LL)) )
961 int arM = (int) ((instr & 0x00007f00000LL) >> 20);
962 int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
963 int qp = (int) (instr & 0x0000000003fLL);
964 if (qp == 0 && isScratch (rN) && arM == 36 /* ar.unat */)
966 /* We have something like "mov.m r3 = ar.unat". Remember the
967 r3 (or whatever) and watch for a store of this register... */
969 last_prologue_pc = next_pc;
972 else if (it == I && ((instr & 0x1eff8000000LL) == 0x00198000000LL))
975 int rN = (int) ((instr & 0x00000001fc0LL) >> 6);
976 int qp = (int) (instr & 0x0000000003fLL);
977 if (qp == 0 && isScratch (rN))
980 last_prologue_pc = next_pc;
984 && ( ((instr & 0x1ffc8000000LL) == 0x08cc0000000LL)
985 || ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)))
989 st8 [rN] = rM, imm9 */
990 int rN = (int) ((instr & 0x00007f00000LL) >> 20);
991 int rM = (int) ((instr & 0x000000fe000LL) >> 13);
992 int qp = (int) (instr & 0x0000000003fLL);
993 if (qp == 0 && rN == spill_reg && spill_addr != 0
994 && (rM == unat_save_reg || rM == pr_save_reg))
996 /* We've found a spill of either the UNAT register or the PR
997 register. (Well, not exactly; what we've actually found is
998 a spill of the register that UNAT or PR was moved to).
999 Record that fact and move on... */
1000 if (rM == unat_save_reg)
1002 /* Track UNAT register */
1004 frame->saved_regs[IA64_UNAT_REGNUM] = spill_addr;
1009 /* Track PR register */
1011 frame->saved_regs[IA64_PR_REGNUM] = spill_addr;
1014 if ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)
1015 /* st8 [rN] = rM, imm9 */
1016 spill_addr += imm9(instr);
1018 spill_addr = 0; /* must be done spilling */
1019 last_prologue_pc = next_pc;
1021 else if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1023 /* Allow up to one store of each input register. */
1024 instores[rM-32] = 1;
1025 last_prologue_pc = next_pc;
1028 else if (it == M && ((instr & 0x1ff08000000LL) == 0x08c00000000LL))
1035 Note that the st8 case is handled in the clause above.
1037 Advance over stores of input registers. One store per input
1038 register is permitted. */
1039 int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1040 int qp = (int) (instr & 0x0000000003fLL);
1041 if (qp == 0 && 32 <= rM && rM < 40 && !instores[rM-32])
1043 instores[rM-32] = 1;
1044 last_prologue_pc = next_pc;
1047 else if (it == M && ((instr & 0x1ff88000000LL) == 0x0cc80000000LL))
1054 Advance over stores of floating point input registers. Again
1055 one store per register is permitted */
1056 int fM = (int) ((instr & 0x000000fe000LL) >> 13);
1057 int qp = (int) (instr & 0x0000000003fLL);
1058 if (qp == 0 && 8 <= fM && fM < 16 && !infpstores[fM - 8])
1060 infpstores[fM-8] = 1;
1061 last_prologue_pc = next_pc;
1065 && ( ((instr & 0x1ffc8000000LL) == 0x08ec0000000LL)
1066 || ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)))
1068 /* st8.spill [rN] = rM
1070 st8.spill [rN] = rM, imm9 */
1071 int rN = (int) ((instr & 0x00007f00000LL) >> 20);
1072 int rM = (int) ((instr & 0x000000fe000LL) >> 13);
1073 int qp = (int) (instr & 0x0000000003fLL);
1074 if (qp == 0 && rN == spill_reg && 4 <= rM && rM <= 7)
1076 /* We've found a spill of one of the preserved general purpose
1077 regs. Record the spill address and advance the spill
1078 register if appropriate. */
1080 frame->saved_regs[IA64_GR0_REGNUM + rM] = spill_addr;
1081 if ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)
1082 /* st8.spill [rN] = rM, imm9 */
1083 spill_addr += imm9(instr);
1085 spill_addr = 0; /* Done spilling */
1086 last_prologue_pc = next_pc;
1098 /* Extract the size of the rotating portion of the stack
1099 frame and the register rename base from the current
1101 sor = ((frame->extra_info->cfm >> 14) & 0xf) * 8;
1102 rrb_gr = (frame->extra_info->cfm >> 18) & 0x7f;
1104 for (i = 0, addr = frame->extra_info->bsp;
1105 i < frame->extra_info->sof;
1108 if (IS_NaT_COLLECTION_ADDR (addr))
1113 frame->saved_regs[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
1116 frame->saved_regs[IA64_GR32_REGNUM + i] = addr;
1118 if (i+32 == cfm_reg)
1119 frame->saved_regs[IA64_CFM_REGNUM] = addr;
1120 if (i+32 == ret_reg)
1121 frame->saved_regs[IA64_VRAP_REGNUM] = addr;
1123 frame->saved_regs[IA64_VFP_REGNUM] = addr;
1127 if (frame && frame->extra_info) {
1128 frame->extra_info->after_prologue = last_prologue_pc;
1129 frame->extra_info->mem_stack_frame_size = mem_stack_frame_size;
1130 frame->extra_info->fp_reg = fp_reg;
1133 return last_prologue_pc;
1137 ia64_skip_prologue (CORE_ADDR pc)
1139 return examine_prologue (pc, pc+1024, 0);
1143 ia64_frame_init_saved_regs (struct frame_info *frame)
1145 if (frame->saved_regs)
1148 if (frame->signal_handler_caller && SIGCONTEXT_REGISTER_ADDRESS)
1152 frame_saved_regs_zalloc (frame);
1154 frame->saved_regs[IA64_VRAP_REGNUM] =
1155 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_IP_REGNUM);
1156 frame->saved_regs[IA64_CFM_REGNUM] =
1157 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CFM_REGNUM);
1158 frame->saved_regs[IA64_PSR_REGNUM] =
1159 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PSR_REGNUM);
1161 frame->saved_regs[IA64_BSP_REGNUM] =
1162 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_BSP_REGNUM);
1164 frame->saved_regs[IA64_RNAT_REGNUM] =
1165 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_RNAT_REGNUM);
1166 frame->saved_regs[IA64_CCV_REGNUM] =
1167 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CCV_REGNUM);
1168 frame->saved_regs[IA64_UNAT_REGNUM] =
1169 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_UNAT_REGNUM);
1170 frame->saved_regs[IA64_FPSR_REGNUM] =
1171 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_FPSR_REGNUM);
1172 frame->saved_regs[IA64_PFS_REGNUM] =
1173 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PFS_REGNUM);
1174 frame->saved_regs[IA64_LC_REGNUM] =
1175 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_LC_REGNUM);
1176 for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
1177 if (regno != sp_regnum)
1178 frame->saved_regs[regno] =
1179 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1180 for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1181 frame->saved_regs[regno] =
1182 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1183 for (regno = IA64_FR2_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
1184 frame->saved_regs[regno] =
1185 SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
1189 CORE_ADDR func_start;
1191 func_start = get_pc_function_start (frame->pc);
1192 examine_prologue (func_start, frame->pc, frame);
1197 ia64_get_saved_register (char *raw_buffer,
1200 struct frame_info *frame,
1202 enum lval_type *lval)
1206 if (!target_has_registers)
1207 error ("No registers.");
1209 if (optimized != NULL)
1218 is_dummy_frame = PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame);
1220 if (regnum == SP_REGNUM && frame->next)
1222 /* Handle SP values for all frames but the topmost. */
1223 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->frame);
1225 else if (regnum == IA64_BSP_REGNUM)
1227 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1228 frame->extra_info->bsp);
1230 else if (regnum == IA64_VFP_REGNUM)
1232 /* If the function in question uses an automatic register (r32-r127)
1233 for the frame pointer, it'll be found by ia64_find_saved_register()
1234 above. If the function lacks one of these frame pointers, we can
1235 still provide a value since we know the size of the frame */
1236 CORE_ADDR vfp = frame->frame + frame->extra_info->mem_stack_frame_size;
1237 store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
1239 else if (IA64_PR0_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1241 char *pr_raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
1243 enum lval_type pr_lval;
1246 ia64_get_saved_register (pr_raw_buffer, &pr_optim, &pr_addr,
1247 frame, IA64_PR_REGNUM, &pr_lval);
1248 if (IA64_PR16_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
1250 /* Fetch predicate register rename base from current frame
1251 marker for this frame. */
1252 int rrb_pr = (frame->extra_info->cfm >> 32) & 0x3f;
1254 /* Adjust the register number to account for register rotation. */
1255 regnum = IA64_PR16_REGNUM
1256 + ((regnum - IA64_PR16_REGNUM) + rrb_pr) % 48;
1258 prN_val = extract_bit_field ((unsigned char *) pr_raw_buffer,
1259 regnum - IA64_PR0_REGNUM, 1);
1260 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), prN_val);
1262 else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
1264 char *unat_raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
1266 enum lval_type unat_lval;
1267 CORE_ADDR unat_addr;
1269 ia64_get_saved_register (unat_raw_buffer, &unat_optim, &unat_addr,
1270 frame, IA64_UNAT_REGNUM, &unat_lval);
1271 unatN_val = extract_bit_field ((unsigned char *) unat_raw_buffer,
1272 regnum - IA64_NAT0_REGNUM, 1);
1273 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
1276 else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
1279 /* Find address of general register corresponding to nat bit we're
1281 CORE_ADDR gr_addr = 0;
1283 if (!is_dummy_frame)
1285 FRAME_INIT_SAVED_REGS (frame);
1286 gr_addr = frame->saved_regs[ regnum - IA64_NAT0_REGNUM
1291 /* Compute address of nat collection bits */
1292 CORE_ADDR nat_addr = gr_addr | 0x1f8;
1293 CORE_ADDR bsp = read_register (IA64_BSP_REGNUM);
1294 CORE_ADDR nat_collection;
1296 /* If our nat collection address is bigger than bsp, we have to get
1297 the nat collection from rnat. Otherwise, we fetch the nat
1298 collection from the computed address. */
1299 if (nat_addr >= bsp)
1300 nat_collection = read_register (IA64_RNAT_REGNUM);
1302 nat_collection = read_memory_integer (nat_addr, 8);
1303 nat_bit = (gr_addr >> 3) & 0x3f;
1304 natval = (nat_collection >> nat_bit) & 1;
1306 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), natval);
1308 else if (regnum == IA64_IP_REGNUM)
1313 /* FIXME: Set *addrp, *lval when possible. */
1314 pc = ia64_frame_saved_pc (frame->next);
1320 store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_IP_REGNUM), pc);
1322 else if (IA64_GR32_REGNUM <= regnum && regnum <= IA64_GR127_REGNUM)
1325 if (!is_dummy_frame)
1327 FRAME_INIT_SAVED_REGS (frame);
1328 addr = frame->saved_regs[regnum];
1334 *lval = lval_memory;
1337 read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
1341 /* r32 - r127 must be fetchable via memory. If they aren't,
1342 then the register is unavailable */
1343 memset (raw_buffer, 0, REGISTER_RAW_SIZE (regnum));
1348 if (IA64_FR32_REGNUM <= regnum && regnum <= IA64_FR127_REGNUM)
1350 /* Fetch floating point register rename base from current
1351 frame marker for this frame. */
1352 int rrb_fr = (frame->extra_info->cfm >> 25) & 0x7f;
1354 /* Adjust the floating point register number to account for
1355 register rotation. */
1356 regnum = IA64_FR32_REGNUM
1357 + ((regnum - IA64_FR32_REGNUM) + rrb_fr) % 96;
1360 generic_get_saved_register (raw_buffer, optimized, addrp, frame,
1365 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1366 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1367 and TYPE is the type (which is known to be struct, union or array). */
1369 ia64_use_struct_convention (int gcc_p, struct type *type)
1371 struct type *float_elt_type;
1373 /* HFAs are structures (or arrays) consisting entirely of floating
1374 point values of the same length. Up to 8 of these are returned
1375 in registers. Don't use the struct convention when this is the
1377 float_elt_type = is_float_or_hfa_type (type);
1378 if (float_elt_type != NULL
1379 && TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type) <= 8)
1382 /* Other structs of length 32 or less are returned in r8-r11.
1383 Don't use the struct convention for those either. */
1384 return TYPE_LENGTH (type) > 32;
1388 ia64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1390 struct type *float_elt_type;
1392 float_elt_type = is_float_or_hfa_type (type);
1393 if (float_elt_type != NULL)
1396 int regnum = IA64_FR8_REGNUM;
1397 int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
1401 ia64_register_convert_to_virtual (regnum, float_elt_type,
1402 ®buf[REGISTER_BYTE (regnum)], valbuf + offset);
1403 offset += TYPE_LENGTH (float_elt_type);
1408 memcpy (valbuf, ®buf[REGISTER_BYTE (IA64_GR8_REGNUM)],
1409 TYPE_LENGTH (type));
1412 /* FIXME: Turn this into a stack of some sort. Unfortunately, something
1413 like this is necessary though since the IA-64 calling conventions specify
1414 that r8 is not preserved. */
1415 static CORE_ADDR struct_return_address;
1418 ia64_extract_struct_value_address (char *regbuf)
1420 /* FIXME: See above. */
1421 return struct_return_address;
1425 ia64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1427 /* FIXME: See above. */
1428 /* Note that most of the work was done in ia64_push_arguments() */
1429 struct_return_address = addr;
1433 ia64_frameless_function_invocation (struct frame_info *frame)
1435 FRAME_INIT_SAVED_REGS (frame);
1436 return (frame->extra_info->mem_stack_frame_size == 0);
1440 ia64_saved_pc_after_call (struct frame_info *frame)
1442 return read_register (IA64_BR0_REGNUM);
1446 ia64_frame_args_address (struct frame_info *frame)
1448 /* frame->frame points at the SP for this frame; But we want the start
1449 of the frame, not the end. Calling frame chain will get his for us. */
1450 return ia64_frame_chain (frame);
1454 ia64_frame_locals_address (struct frame_info *frame)
1456 /* frame->frame points at the SP for this frame; But we want the start
1457 of the frame, not the end. Calling frame chain will get his for us. */
1458 return ia64_frame_chain (frame);
1462 ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
1465 int next_frame_is_call_dummy = ((frame->next != NULL)
1466 && PC_IN_CALL_DUMMY (frame->next->pc, frame->next->frame,
1467 frame->next->frame));
1469 frame->extra_info = (struct frame_extra_info *)
1470 frame_obstack_alloc (sizeof (struct frame_extra_info));
1472 if (frame->next == 0)
1474 bsp = read_register (IA64_BSP_REGNUM);
1475 cfm = read_register (IA64_CFM_REGNUM);
1478 else if (frame->next->signal_handler_caller)
1480 bsp = read_sigcontext_register (frame->next, IA64_BSP_REGNUM);
1481 cfm = read_sigcontext_register (frame->next, IA64_CFM_REGNUM);
1483 else if (next_frame_is_call_dummy)
1485 bsp = generic_read_register_dummy (frame->next->pc, frame->next->frame,
1487 cfm = generic_read_register_dummy (frame->next->pc, frame->next->frame,
1492 struct frame_info *frn = frame->next;
1494 FRAME_INIT_SAVED_REGS (frn);
1496 if (frn->saved_regs[IA64_CFM_REGNUM] != 0)
1497 cfm = read_memory_integer (frn->saved_regs[IA64_CFM_REGNUM], 8);
1498 else if (frn->next && frn->next->signal_handler_caller)
1499 cfm = read_sigcontext_register (frn->next, IA64_PFS_REGNUM);
1501 && PC_IN_CALL_DUMMY (frn->next->pc, frn->next->frame,
1503 cfm = generic_read_register_dummy (frn->next->pc, frn->next->frame,
1506 cfm = read_register (IA64_PFS_REGNUM);
1508 bsp = frn->extra_info->bsp;
1510 frame->extra_info->cfm = cfm;
1511 frame->extra_info->sof = cfm & 0x7f;
1512 frame->extra_info->sol = (cfm >> 7) & 0x7f;
1513 if (frame->next == 0
1514 || frame->next->signal_handler_caller
1515 || next_frame_is_call_dummy)
1516 frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sof);
1518 frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sol);
1520 frame->extra_info->after_prologue = 0;
1521 frame->extra_info->mem_stack_frame_size = -1; /* Not yet determined */
1522 frame->extra_info->fp_reg = 0;
1526 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
1528 switch (TYPE_CODE (t))
1532 return TYPE_LENGTH (*etp) == TYPE_LENGTH (t);
1539 case TYPE_CODE_ARRAY:
1541 is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t)),
1544 case TYPE_CODE_STRUCT:
1548 for (i = 0; i < TYPE_NFIELDS (t); i++)
1549 if (!is_float_or_hfa_type_recurse
1550 (check_typedef (TYPE_FIELD_TYPE (t, i)), etp))
1561 /* Determine if the given type is one of the floating point types or
1562 and HFA (which is a struct, array, or combination thereof whose
1563 bottom-most elements are all of the same floating point type.) */
1565 static struct type *
1566 is_float_or_hfa_type (struct type *t)
1568 struct type *et = 0;
1570 return is_float_or_hfa_type_recurse (t, &et) ? et : 0;
1574 /* Return 1 if the alignment of T is such that the next even slot
1575 should be used. Return 0, if the next available slot should
1576 be used. (See section 8.5.1 of the IA-64 Software Conventions
1577 and Runtime manual.) */
1580 slot_alignment_is_next_even (struct type *t)
1582 switch (TYPE_CODE (t))
1586 if (TYPE_LENGTH (t) > 8)
1590 case TYPE_CODE_ARRAY:
1592 slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t)));
1593 case TYPE_CODE_STRUCT:
1597 for (i = 0; i < TYPE_NFIELDS (t); i++)
1598 if (slot_alignment_is_next_even
1599 (check_typedef (TYPE_FIELD_TYPE (t, i))))
1608 /* Attempt to find (and return) the global pointer for the given
1611 This is a rather nasty bit of code searchs for the .dynamic section
1612 in the objfile corresponding to the pc of the function we're trying
1613 to call. Once it finds the addresses at which the .dynamic section
1614 lives in the child process, it scans the Elf64_Dyn entries for a
1615 DT_PLTGOT tag. If it finds one of these, the corresponding
1616 d_un.d_ptr value is the global pointer. */
1619 generic_elf_find_global_pointer (CORE_ADDR faddr)
1621 struct obj_section *faddr_sect;
1623 faddr_sect = find_pc_section (faddr);
1624 if (faddr_sect != NULL)
1626 struct obj_section *osect;
1628 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1630 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
1634 if (osect < faddr_sect->objfile->sections_end)
1639 while (addr < osect->endaddr)
1645 status = target_read_memory (addr, buf, sizeof (buf));
1648 tag = extract_signed_integer (buf, sizeof (buf));
1650 if (tag == DT_PLTGOT)
1652 CORE_ADDR global_pointer;
1654 status = target_read_memory (addr + 8, buf, sizeof (buf));
1657 global_pointer = extract_address (buf, sizeof (buf));
1660 return global_pointer;
1673 /* Given a function's address, attempt to find (and return) the
1674 corresponding (canonical) function descriptor. Return 0 if
1677 find_extant_func_descr (CORE_ADDR faddr)
1679 struct obj_section *faddr_sect;
1681 /* Return early if faddr is already a function descriptor */
1682 faddr_sect = find_pc_section (faddr);
1683 if (faddr_sect && strcmp (faddr_sect->the_bfd_section->name, ".opd") == 0)
1686 if (faddr_sect != NULL)
1688 struct obj_section *osect;
1689 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1691 if (strcmp (osect->the_bfd_section->name, ".opd") == 0)
1695 if (osect < faddr_sect->objfile->sections_end)
1700 while (addr < osect->endaddr)
1706 status = target_read_memory (addr, buf, sizeof (buf));
1709 faddr2 = extract_signed_integer (buf, sizeof (buf));
1711 if (faddr == faddr2)
1721 /* Attempt to find a function descriptor corresponding to the
1722 given address. If none is found, construct one on the
1723 stack using the address at fdaptr */
1726 find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
1730 fdesc = find_extant_func_descr (faddr);
1734 CORE_ADDR global_pointer;
1740 global_pointer = FIND_GLOBAL_POINTER (faddr);
1742 if (global_pointer == 0)
1743 global_pointer = read_register (IA64_GR1_REGNUM);
1745 store_address (buf, 8, faddr);
1746 store_address (buf + 8, 8, global_pointer);
1748 write_memory (fdesc, buf, 16);
1755 ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1756 int struct_return, CORE_ADDR struct_addr)
1762 int nslots, rseslots, memslots, slotnum, nfuncargs;
1764 CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr;
1768 /* Count the number of slots needed for the arguments */
1769 for (argno = 0; argno < nargs; argno++)
1772 type = check_typedef (VALUE_TYPE (arg));
1773 len = TYPE_LENGTH (type);
1775 if ((nslots & 1) && slot_alignment_is_next_even (type))
1778 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1781 nslots += (len + 7) / 8;
1784 /* Divvy up the slots between the RSE and the memory stack */
1785 rseslots = (nslots > 8) ? 8 : nslots;
1786 memslots = nslots - rseslots;
1788 /* Allocate a new RSE frame */
1789 cfm = read_register (IA64_CFM_REGNUM);
1791 bsp = read_register (IA64_BSP_REGNUM);
1792 bsp = rse_address_add (bsp, cfm & 0x7f);
1793 new_bsp = rse_address_add (bsp, rseslots);
1794 write_register (IA64_BSP_REGNUM, new_bsp);
1796 pfs = read_register (IA64_PFS_REGNUM);
1797 pfs &= 0xc000000000000000LL;
1798 pfs |= (cfm & 0xffffffffffffLL);
1799 write_register (IA64_PFS_REGNUM, pfs);
1801 cfm &= 0xc000000000000000LL;
1803 write_register (IA64_CFM_REGNUM, cfm);
1805 /* We will attempt to find function descriptors in the .opd segment,
1806 but if we can't we'll construct them ourselves. That being the
1807 case, we'll need to reserve space on the stack for them. */
1808 funcdescaddr = sp - nfuncargs * 16;
1809 funcdescaddr &= ~0xfLL;
1811 /* Adjust the stack pointer to it's new value. The calling conventions
1812 require us to have 16 bytes of scratch, plus whatever space is
1813 necessary for the memory slots and our function descriptors */
1814 sp = sp - 16 - (memslots + nfuncargs) * 8;
1815 sp &= ~0xfLL; /* Maintain 16 byte alignment */
1817 /* Place the arguments where they belong. The arguments will be
1818 either placed in the RSE backing store or on the memory stack.
1819 In addition, floating point arguments or HFAs are placed in
1820 floating point registers. */
1822 floatreg = IA64_FR8_REGNUM;
1823 for (argno = 0; argno < nargs; argno++)
1825 struct type *float_elt_type;
1828 type = check_typedef (VALUE_TYPE (arg));
1829 len = TYPE_LENGTH (type);
1831 /* Special handling for function parameters */
1833 && TYPE_CODE (type) == TYPE_CODE_PTR
1834 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1838 store_address (val_buf, 8,
1839 find_func_descr (extract_address (VALUE_CONTENTS (arg), 8),
1841 if (slotnum < rseslots)
1842 write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1844 write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1851 /* Skip odd slot if necessary... */
1852 if ((slotnum & 1) && slot_alignment_is_next_even (type))
1860 memset (val_buf, 0, 8);
1861 memcpy (val_buf, VALUE_CONTENTS (arg) + argoffset, (len > 8) ? 8 : len);
1863 if (slotnum < rseslots)
1864 write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
1866 write_memory (sp + 16 + 8 * (slotnum - rseslots), val_buf, 8);
1873 /* Handle floating point types (including HFAs) */
1874 float_elt_type = is_float_or_hfa_type (type);
1875 if (float_elt_type != NULL)
1878 len = TYPE_LENGTH (type);
1879 while (len > 0 && floatreg < IA64_FR16_REGNUM)
1881 ia64_register_convert_to_raw (
1884 VALUE_CONTENTS (arg) + argoffset,
1885 ®isters[REGISTER_BYTE (floatreg)]);
1887 argoffset += TYPE_LENGTH (float_elt_type);
1888 len -= TYPE_LENGTH (float_elt_type);
1893 /* Store the struct return value in r8 if necessary. */
1896 store_address (®isters[REGISTER_BYTE (IA64_GR8_REGNUM)],
1897 REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
1901 /* Sync gdb's idea of what the registers are with the target. */
1902 target_store_registers (-1);
1904 /* FIXME: This doesn't belong here! Instead, SAVE_DUMMY_FRAME_TOS needs
1905 to be defined to call generic_save_dummy_frame_tos(). But at the
1906 time of this writing, SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so
1907 I chose to put this call here instead of using the old mechanisms.
1908 Once SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do is add the
1911 set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1913 to ia64_gdbarch_init() and remove the line below. */
1914 generic_save_dummy_frame_tos (sp);
1920 ia64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1922 CORE_ADDR global_pointer = FIND_GLOBAL_POINTER (pc);
1924 if (global_pointer != 0)
1925 write_register (IA64_GR1_REGNUM, global_pointer);
1927 write_register (IA64_BR0_REGNUM, CALL_DUMMY_ADDRESS ());
1932 ia64_store_return_value (struct type *type, char *valbuf)
1934 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1936 ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
1937 ®isters[REGISTER_BYTE (IA64_FR8_REGNUM)]);
1938 target_store_registers (IA64_FR8_REGNUM);
1941 write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
1942 valbuf, TYPE_LENGTH (type));
1946 ia64_pop_frame (void)
1948 generic_pop_current_frame (ia64_pop_frame_regular);
1952 ia64_pop_frame_regular (struct frame_info *frame)
1955 CORE_ADDR bsp, cfm, pfs;
1957 FRAME_INIT_SAVED_REGS (frame);
1959 for (regno = 0; regno < ia64_num_regs; regno++)
1961 if (frame->saved_regs[regno]
1962 && (!(IA64_GR32_REGNUM <= regno && regno <= IA64_GR127_REGNUM))
1963 && regno != pc_regnum
1964 && regno != sp_regnum
1965 && regno != IA64_PFS_REGNUM
1966 && regno != IA64_CFM_REGNUM
1967 && regno != IA64_BSP_REGNUM
1968 && regno != IA64_BSPSTORE_REGNUM)
1970 write_register (regno,
1971 read_memory_integer (frame->saved_regs[regno],
1972 REGISTER_RAW_SIZE (regno)));
1976 write_register (sp_regnum, FRAME_CHAIN (frame));
1977 write_pc (FRAME_SAVED_PC (frame));
1979 cfm = read_register (IA64_CFM_REGNUM);
1981 if (frame->saved_regs[IA64_PFS_REGNUM])
1983 pfs = read_memory_integer (frame->saved_regs[IA64_PFS_REGNUM],
1984 REGISTER_RAW_SIZE (IA64_PFS_REGNUM));
1987 pfs = read_register (IA64_PFS_REGNUM);
1989 /* Compute the new bsp by *adding* the difference between the
1990 size of the frame and the size of the locals (both wrt the
1991 frame that we're going back to). This seems kind of strange,
1992 especially since it seems like we ought to be subtracting the
1993 size of the locals... and we should; but the Linux kernel
1994 wants bsp to be set at the end of all used registers. It's
1995 likely that this code will need to be revised to accomodate
1996 other operating systems. */
1997 bsp = rse_address_add (frame->extra_info->bsp,
1998 (pfs & 0x7f) - ((pfs >> 7) & 0x7f));
1999 write_register (IA64_BSP_REGNUM, bsp);
2001 /* FIXME: What becomes of the epilog count in the PFS? */
2002 cfm = (cfm & ~0xffffffffffffLL) | (pfs & 0xffffffffffffLL);
2003 write_register (IA64_CFM_REGNUM, cfm);
2005 flush_cached_frames ();
2009 ia64_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
2010 CORE_ADDR *targ_addr, int *targ_len)
2012 *targ_addr = memaddr;
2013 *targ_len = nr_bytes;
2017 process_note_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
2019 int *os_ident_ptr = obj;
2021 unsigned int sectsize;
2023 name = bfd_get_section_name (abfd, sect);
2024 sectsize = bfd_section_size (abfd, sect);
2025 if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
2027 unsigned int name_length, data_length, note_type;
2028 char *note = alloca (sectsize);
2030 bfd_get_section_contents (abfd, sect, note,
2031 (file_ptr) 0, (bfd_size_type) sectsize);
2033 name_length = bfd_h_get_32 (abfd, note);
2034 data_length = bfd_h_get_32 (abfd, note + 4);
2035 note_type = bfd_h_get_32 (abfd, note + 8);
2037 if (name_length == 4 && data_length == 16 && note_type == 1
2038 && strcmp (note + 12, "GNU") == 0)
2040 int os_number = bfd_h_get_32 (abfd, note + 16);
2042 /* The case numbers are from abi-tags in glibc */
2046 *os_ident_ptr = ELFOSABI_LINUX;
2049 *os_ident_ptr = ELFOSABI_HURD;
2052 *os_ident_ptr = ELFOSABI_SOLARIS;
2055 internal_error (__FILE__, __LINE__,
2056 "process_note_abi_sections: unknown OS number %d", os_number);
2063 static struct gdbarch *
2064 ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2066 struct gdbarch *gdbarch;
2067 struct gdbarch_tdep *tdep;
2070 if (info.abfd != NULL
2071 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2073 os_ident = elf_elfheader (info.abfd)->e_ident[EI_OSABI];
2075 /* If os_ident is 0, it is not necessarily the case that we're
2076 on a SYSV system. (ELFOSABI_NONE is defined to be 0.)
2077 GNU/Linux uses a note section to record OS/ABI info, but
2078 leaves e_ident[EI_OSABI] zero. So we have to check for note
2082 bfd_map_over_sections (info.abfd,
2083 process_note_abi_tag_sections,
2090 for (arches = gdbarch_list_lookup_by_info (arches, &info);
2092 arches = gdbarch_list_lookup_by_info (arches->next, &info))
2094 tdep = gdbarch_tdep (arches->gdbarch);
2095 if (tdep &&tdep->os_ident == os_ident)
2096 return arches->gdbarch;
2099 tdep = xmalloc (sizeof (struct gdbarch_tdep));
2100 gdbarch = gdbarch_alloc (&info, tdep);
2101 tdep->os_ident = os_ident;
2104 /* Set the method of obtaining the sigcontext addresses at which
2105 registers are saved. The method of checking to see if
2106 native_find_global_pointer is nonzero to indicate that we're
2107 on AIX is kind of hokey, but I can't think of a better way
2109 if (os_ident == ELFOSABI_LINUX)
2110 tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
2111 else if (native_find_global_pointer != 0)
2112 tdep->sigcontext_register_address = ia64_aix_sigcontext_register_address;
2114 tdep->sigcontext_register_address = 0;
2116 /* We know that GNU/Linux won't have to resort to the
2117 native_find_global_pointer hackery. But that's the only one we
2118 know about so far, so if native_find_global_pointer is set to
2119 something non-zero, then use it. Otherwise fall back to using
2120 generic_elf_find_global_pointer. This arrangement should (in
2121 theory) allow us to cross debug GNU/Linux binaries from an AIX
2123 if (os_ident == ELFOSABI_LINUX)
2124 tdep->find_global_pointer = generic_elf_find_global_pointer;
2125 else if (native_find_global_pointer != 0)
2126 tdep->find_global_pointer = native_find_global_pointer;
2128 tdep->find_global_pointer = generic_elf_find_global_pointer;
2130 set_gdbarch_short_bit (gdbarch, 16);
2131 set_gdbarch_int_bit (gdbarch, 32);
2132 set_gdbarch_long_bit (gdbarch, 64);
2133 set_gdbarch_long_long_bit (gdbarch, 64);
2134 set_gdbarch_float_bit (gdbarch, 32);
2135 set_gdbarch_double_bit (gdbarch, 64);
2136 set_gdbarch_long_double_bit (gdbarch, 64);
2137 set_gdbarch_ptr_bit (gdbarch, 64);
2139 set_gdbarch_num_regs (gdbarch, ia64_num_regs);
2140 set_gdbarch_sp_regnum (gdbarch, sp_regnum);
2141 set_gdbarch_fp_regnum (gdbarch, fp_regnum);
2142 set_gdbarch_pc_regnum (gdbarch, pc_regnum);
2143 set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
2145 set_gdbarch_register_name (gdbarch, ia64_register_name);
2146 set_gdbarch_register_size (gdbarch, 8);
2147 set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
2148 set_gdbarch_register_byte (gdbarch, ia64_register_byte);
2149 set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
2150 set_gdbarch_max_register_raw_size (gdbarch, 16);
2151 set_gdbarch_register_virtual_size (gdbarch, ia64_register_virtual_size);
2152 set_gdbarch_max_register_virtual_size (gdbarch, 16);
2153 set_gdbarch_register_virtual_type (gdbarch, ia64_register_virtual_type);
2155 set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
2157 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
2158 set_gdbarch_frameless_function_invocation (gdbarch, ia64_frameless_function_invocation);
2160 set_gdbarch_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
2162 set_gdbarch_frame_chain (gdbarch, ia64_frame_chain);
2163 set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
2164 set_gdbarch_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
2166 set_gdbarch_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
2167 set_gdbarch_get_saved_register (gdbarch, ia64_get_saved_register);
2169 set_gdbarch_register_convertible (gdbarch, ia64_register_convertible);
2170 set_gdbarch_register_convert_to_virtual (gdbarch, ia64_register_convert_to_virtual);
2171 set_gdbarch_register_convert_to_raw (gdbarch, ia64_register_convert_to_raw);
2173 set_gdbarch_use_struct_convention (gdbarch, ia64_use_struct_convention);
2174 set_gdbarch_extract_return_value (gdbarch, ia64_extract_return_value);
2176 set_gdbarch_store_struct_return (gdbarch, ia64_store_struct_return);
2177 set_gdbarch_store_return_value (gdbarch, ia64_store_return_value);
2178 set_gdbarch_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
2180 set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
2181 set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
2182 set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc);
2183 set_gdbarch_read_pc (gdbarch, ia64_read_pc);
2184 set_gdbarch_write_pc (gdbarch, ia64_write_pc);
2186 /* Settings for calling functions in the inferior. */
2187 set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
2188 set_gdbarch_call_dummy_length (gdbarch, 0);
2189 set_gdbarch_push_arguments (gdbarch, ia64_push_arguments);
2190 set_gdbarch_push_return_address (gdbarch, ia64_push_return_address);
2191 set_gdbarch_pop_frame (gdbarch, ia64_pop_frame);
2193 set_gdbarch_call_dummy_p (gdbarch, 1);
2194 set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
2195 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
2196 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
2197 set_gdbarch_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
2198 set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
2199 set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
2201 /* We won't necessarily have a frame pointer and even if we do,
2202 it winds up being extraordinarly messy when attempting to find
2203 the frame chain. So for the purposes of creating frames (which
2204 is all read_fp() is used for), simply use the stack pointer value
2206 set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
2207 set_gdbarch_write_fp (gdbarch, generic_target_write_sp);
2209 /* Settings that should be unnecessary. */
2210 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2212 set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
2213 set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
2215 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
2216 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
2217 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
2218 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
2219 set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
2220 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
2221 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
2222 set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
2224 set_gdbarch_decr_pc_after_break (gdbarch, 0);
2225 set_gdbarch_function_start_offset (gdbarch, 0);
2227 set_gdbarch_remote_translate_xfer_address (
2228 gdbarch, ia64_remote_translate_xfer_address);
2234 _initialize_ia64_tdep (void)
2236 register_gdbarch_init (bfd_arch_ia64, ia64_gdbarch_init);
2238 tm_print_insn = print_insn_ia64;
2239 tm_print_insn_info.bytes_per_line = SLOT_MULTIPLIER;