1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
25 #include "floatformat.h"
28 #include "reggroups.h"
30 #include "frame-base.h"
31 #include "frame-unwind.h"
34 #include "gdb_assert.h"
36 #include "elf/common.h" /* for DT_PLTGOT value */
41 #include "ia64-tdep.h"
44 #ifdef HAVE_LIBUNWIND_IA64_H
45 #include "elf/ia64.h" /* for PT_IA_64_UNWIND value */
46 #include "libunwind-frame.h"
47 #include "libunwind-ia64.h"
49 /* Note: KERNEL_START is supposed to be an address which is not going
50 to ever contain any valid unwind info. For ia64 linux, the choice
51 of 0xc000000000000000 is fairly safe since that's uncached space.
53 We use KERNEL_START as follows: after obtaining the kernel's
54 unwind table via getunwind(), we project its unwind data into
55 address-range KERNEL_START-(KERNEL_START+ktab_size) and then
56 when ia64_access_mem() sees a memory access to this
57 address-range, we redirect it to ktab instead.
59 None of this hackery is needed with a modern kernel/libcs
60 which uses the kernel virtual DSO to provide access to the
61 kernel's unwind info. In that case, ktab_size remains 0 and
62 hence the value of KERNEL_START doesn't matter. */
64 #define KERNEL_START 0xc000000000000000ULL
66 static size_t ktab_size
= 0;
67 struct ia64_table_entry
69 uint64_t start_offset
;
74 static struct ia64_table_entry
*ktab
= NULL
;
78 /* An enumeration of the different IA-64 instruction types. */
80 typedef enum instruction_type
82 A
, /* Integer ALU ; I-unit or M-unit */
83 I
, /* Non-ALU integer; I-unit */
84 M
, /* Memory ; M-unit */
85 F
, /* Floating-point ; F-unit */
86 B
, /* Branch ; B-unit */
87 L
, /* Extended (L+X) ; I-unit */
88 X
, /* Extended (L+X) ; I-unit */
89 undefined
/* undefined or reserved */
92 /* We represent IA-64 PC addresses as the value of the instruction
93 pointer or'd with some bit combination in the low nibble which
94 represents the slot number in the bundle addressed by the
95 instruction pointer. The problem is that the Linux kernel
96 multiplies its slot numbers (for exceptions) by one while the
97 disassembler multiplies its slot numbers by 6. In addition, I've
98 heard it said that the simulator uses 1 as the multiplier.
100 I've fixed the disassembler so that the bytes_per_line field will
101 be the slot multiplier. If bytes_per_line comes in as zero, it
102 is set to six (which is how it was set up initially). -- objdump
103 displays pretty disassembly dumps with this value. For our purposes,
104 we'll set bytes_per_line to SLOT_MULTIPLIER. This is okay since we
105 never want to also display the raw bytes the way objdump does. */
107 #define SLOT_MULTIPLIER 1
109 /* Length in bytes of an instruction bundle */
111 #define BUNDLE_LEN 16
113 /* See the saved memory layout comment for ia64_memory_insert_breakpoint. */
115 #if BREAKPOINT_MAX < BUNDLE_LEN - 2
116 # error "BREAKPOINT_MAX < BUNDLE_LEN - 2"
119 static gdbarch_init_ftype ia64_gdbarch_init
;
121 static gdbarch_register_name_ftype ia64_register_name
;
122 static gdbarch_register_type_ftype ia64_register_type
;
123 static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc
;
124 static gdbarch_skip_prologue_ftype ia64_skip_prologue
;
125 static struct type
*is_float_or_hfa_type (struct type
*t
);
126 static CORE_ADDR
ia64_find_global_pointer (struct gdbarch
*gdbarch
,
129 #define NUM_IA64_RAW_REGS 462
131 static int sp_regnum
= IA64_GR12_REGNUM
;
132 static int fp_regnum
= IA64_VFP_REGNUM
;
133 static int lr_regnum
= IA64_VRAP_REGNUM
;
135 /* NOTE: we treat the register stack registers r32-r127 as pseudo-registers because
136 they may not be accessible via the ptrace register get/set interfaces. */
137 enum pseudo_regs
{ FIRST_PSEUDO_REGNUM
= NUM_IA64_RAW_REGS
, VBOF_REGNUM
= IA64_NAT127_REGNUM
+ 1, V32_REGNUM
,
138 V127_REGNUM
= V32_REGNUM
+ 95,
139 VP0_REGNUM
, VP16_REGNUM
= VP0_REGNUM
+ 16, VP63_REGNUM
= VP0_REGNUM
+ 63, LAST_PSEUDO_REGNUM
};
141 /* Array of register names; There should be ia64_num_regs strings in
144 static char *ia64_register_names
[] =
145 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
146 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
147 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
148 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
149 "", "", "", "", "", "", "", "",
150 "", "", "", "", "", "", "", "",
151 "", "", "", "", "", "", "", "",
152 "", "", "", "", "", "", "", "",
153 "", "", "", "", "", "", "", "",
154 "", "", "", "", "", "", "", "",
155 "", "", "", "", "", "", "", "",
156 "", "", "", "", "", "", "", "",
157 "", "", "", "", "", "", "", "",
158 "", "", "", "", "", "", "", "",
159 "", "", "", "", "", "", "", "",
160 "", "", "", "", "", "", "", "",
162 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
163 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
164 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
165 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
166 "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
167 "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47",
168 "f48", "f49", "f50", "f51", "f52", "f53", "f54", "f55",
169 "f56", "f57", "f58", "f59", "f60", "f61", "f62", "f63",
170 "f64", "f65", "f66", "f67", "f68", "f69", "f70", "f71",
171 "f72", "f73", "f74", "f75", "f76", "f77", "f78", "f79",
172 "f80", "f81", "f82", "f83", "f84", "f85", "f86", "f87",
173 "f88", "f89", "f90", "f91", "f92", "f93", "f94", "f95",
174 "f96", "f97", "f98", "f99", "f100", "f101", "f102", "f103",
175 "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
176 "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
177 "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
179 "", "", "", "", "", "", "", "",
180 "", "", "", "", "", "", "", "",
181 "", "", "", "", "", "", "", "",
182 "", "", "", "", "", "", "", "",
183 "", "", "", "", "", "", "", "",
184 "", "", "", "", "", "", "", "",
185 "", "", "", "", "", "", "", "",
186 "", "", "", "", "", "", "", "",
188 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
192 "pr", "ip", "psr", "cfm",
194 "kr0", "kr1", "kr2", "kr3", "kr4", "kr5", "kr6", "kr7",
195 "", "", "", "", "", "", "", "",
196 "rsc", "bsp", "bspstore", "rnat",
198 "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr", "",
199 "ccv", "", "", "", "unat", "", "", "",
200 "fpsr", "", "", "", "itc",
201 "", "", "", "", "", "", "", "", "", "",
202 "", "", "", "", "", "", "", "", "",
204 "", "", "", "", "", "", "", "", "", "",
205 "", "", "", "", "", "", "", "", "", "",
206 "", "", "", "", "", "", "", "", "", "",
207 "", "", "", "", "", "", "", "", "", "",
208 "", "", "", "", "", "", "", "", "", "",
209 "", "", "", "", "", "", "", "", "", "",
211 "nat0", "nat1", "nat2", "nat3", "nat4", "nat5", "nat6", "nat7",
212 "nat8", "nat9", "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
213 "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
214 "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
215 "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
216 "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
217 "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
218 "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
219 "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
220 "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
221 "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
222 "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
223 "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
224 "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
225 "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
226 "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
230 "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
231 "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
232 "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
233 "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
234 "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
235 "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
236 "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
237 "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
238 "r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
239 "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
240 "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
241 "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
243 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
244 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
245 "p16", "p17", "p18", "p19", "p20", "p21", "p22", "p23",
246 "p24", "p25", "p26", "p27", "p28", "p29", "p30", "p31",
247 "p32", "p33", "p34", "p35", "p36", "p37", "p38", "p39",
248 "p40", "p41", "p42", "p43", "p44", "p45", "p46", "p47",
249 "p48", "p49", "p50", "p51", "p52", "p53", "p54", "p55",
250 "p56", "p57", "p58", "p59", "p60", "p61", "p62", "p63",
253 struct ia64_frame_cache
255 CORE_ADDR base
; /* frame pointer base for frame */
256 CORE_ADDR pc
; /* function start pc for frame */
257 CORE_ADDR saved_sp
; /* stack pointer for frame */
258 CORE_ADDR bsp
; /* points at r32 for the current frame */
259 CORE_ADDR cfm
; /* cfm value for current frame */
260 CORE_ADDR prev_cfm
; /* cfm value for previous frame */
262 int sof
; /* Size of frame (decoded from cfm value) */
263 int sol
; /* Size of locals (decoded from cfm value) */
264 int sor
; /* Number of rotating registers. (decoded from cfm value) */
265 CORE_ADDR after_prologue
;
266 /* Address of first instruction after the last
267 prologue instruction; Note that there may
268 be instructions from the function's body
269 intermingled with the prologue. */
270 int mem_stack_frame_size
;
271 /* Size of the memory stack frame (may be zero),
272 or -1 if it has not been determined yet. */
273 int fp_reg
; /* Register number (if any) used a frame pointer
274 for this frame. 0 if no register is being used
275 as the frame pointer. */
277 /* Saved registers. */
278 CORE_ADDR saved_regs
[NUM_IA64_RAW_REGS
];
283 floatformat_valid (const struct floatformat
*fmt
, const void *from
)
288 static const struct floatformat floatformat_ia64_ext
=
290 floatformat_little
, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
291 floatformat_intbit_yes
, "floatformat_ia64_ext", floatformat_valid
, NULL
294 static const struct floatformat
*floatformats_ia64_ext
[2] =
296 &floatformat_ia64_ext
,
297 &floatformat_ia64_ext
301 ia64_ext_type (struct gdbarch
*gdbarch
)
303 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
305 if (!tdep
->ia64_ext_type
)
307 = arch_float_type (gdbarch
, 128, "builtin_type_ia64_ext",
308 floatformats_ia64_ext
);
310 return tdep
->ia64_ext_type
;
314 ia64_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
315 struct reggroup
*group
)
320 if (group
== all_reggroup
)
322 vector_p
= TYPE_VECTOR (register_type (gdbarch
, regnum
));
323 float_p
= TYPE_CODE (register_type (gdbarch
, regnum
)) == TYPE_CODE_FLT
;
324 raw_p
= regnum
< NUM_IA64_RAW_REGS
;
325 if (group
== float_reggroup
)
327 if (group
== vector_reggroup
)
329 if (group
== general_reggroup
)
330 return (!vector_p
&& !float_p
);
331 if (group
== save_reggroup
|| group
== restore_reggroup
)
337 ia64_register_name (struct gdbarch
*gdbarch
, int reg
)
339 return ia64_register_names
[reg
];
343 ia64_register_type (struct gdbarch
*arch
, int reg
)
345 if (reg
>= IA64_FR0_REGNUM
&& reg
<= IA64_FR127_REGNUM
)
346 return ia64_ext_type (arch
);
348 return builtin_type (arch
)->builtin_long
;
352 ia64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
354 if (reg
>= IA64_GR32_REGNUM
&& reg
<= IA64_GR127_REGNUM
)
355 return V32_REGNUM
+ (reg
- IA64_GR32_REGNUM
);
360 /* Extract ``len'' bits from an instruction bundle starting at
364 extract_bit_field (const char *bundle
, int from
, int len
)
366 long long result
= 0LL;
368 int from_byte
= from
/ 8;
369 int to_byte
= to
/ 8;
370 unsigned char *b
= (unsigned char *) bundle
;
376 if (from_byte
== to_byte
)
377 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
378 result
= c
>> (from
% 8);
379 lshift
= 8 - (from
% 8);
381 for (i
= from_byte
+1; i
< to_byte
; i
++)
383 result
|= ((long long) b
[i
]) << lshift
;
387 if (from_byte
< to_byte
&& (to
% 8 != 0))
390 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
391 result
|= ((long long) c
) << lshift
;
397 /* Replace the specified bits in an instruction bundle */
400 replace_bit_field (char *bundle
, long long val
, int from
, int len
)
403 int from_byte
= from
/ 8;
404 int to_byte
= to
/ 8;
405 unsigned char *b
= (unsigned char *) bundle
;
408 if (from_byte
== to_byte
)
410 unsigned char left
, right
;
412 left
= (c
>> (to
% 8)) << (to
% 8);
413 right
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
414 c
= (unsigned char) (val
& 0xff);
415 c
= (unsigned char) (c
<< (from
% 8 + 8 - to
% 8)) >> (8 - to
% 8);
423 c
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
424 c
= c
| (val
<< (from
% 8));
426 val
>>= 8 - from
% 8;
428 for (i
= from_byte
+1; i
< to_byte
; i
++)
437 unsigned char cv
= (unsigned char) val
;
439 c
= c
>> (to
% 8) << (to
% 8);
440 c
|= ((unsigned char) (cv
<< (8 - to
% 8))) >> (8 - to
% 8);
446 /* Return the contents of slot N (for N = 0, 1, or 2) in
447 and instruction bundle */
450 slotN_contents (char *bundle
, int slotnum
)
452 return extract_bit_field (bundle
, 5+41*slotnum
, 41);
455 /* Store an instruction in an instruction bundle */
458 replace_slotN_contents (char *bundle
, long long instr
, int slotnum
)
460 replace_bit_field (bundle
, instr
, 5+41*slotnum
, 41);
463 static const enum instruction_type template_encoding_table
[32][3] =
465 { M
, I
, I
}, /* 00 */
466 { M
, I
, I
}, /* 01 */
467 { M
, I
, I
}, /* 02 */
468 { M
, I
, I
}, /* 03 */
469 { M
, L
, X
}, /* 04 */
470 { M
, L
, X
}, /* 05 */
471 { undefined
, undefined
, undefined
}, /* 06 */
472 { undefined
, undefined
, undefined
}, /* 07 */
473 { M
, M
, I
}, /* 08 */
474 { M
, M
, I
}, /* 09 */
475 { M
, M
, I
}, /* 0A */
476 { M
, M
, I
}, /* 0B */
477 { M
, F
, I
}, /* 0C */
478 { M
, F
, I
}, /* 0D */
479 { M
, M
, F
}, /* 0E */
480 { M
, M
, F
}, /* 0F */
481 { M
, I
, B
}, /* 10 */
482 { M
, I
, B
}, /* 11 */
483 { M
, B
, B
}, /* 12 */
484 { M
, B
, B
}, /* 13 */
485 { undefined
, undefined
, undefined
}, /* 14 */
486 { undefined
, undefined
, undefined
}, /* 15 */
487 { B
, B
, B
}, /* 16 */
488 { B
, B
, B
}, /* 17 */
489 { M
, M
, B
}, /* 18 */
490 { M
, M
, B
}, /* 19 */
491 { undefined
, undefined
, undefined
}, /* 1A */
492 { undefined
, undefined
, undefined
}, /* 1B */
493 { M
, F
, B
}, /* 1C */
494 { M
, F
, B
}, /* 1D */
495 { undefined
, undefined
, undefined
}, /* 1E */
496 { undefined
, undefined
, undefined
}, /* 1F */
499 /* Fetch and (partially) decode an instruction at ADDR and return the
500 address of the next instruction to fetch. */
503 fetch_instruction (CORE_ADDR addr
, instruction_type
*it
, long long *instr
)
505 char bundle
[BUNDLE_LEN
];
506 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
510 /* Warn about slot numbers greater than 2. We used to generate
511 an error here on the assumption that the user entered an invalid
512 address. But, sometimes GDB itself requests an invalid address.
513 This can (easily) happen when execution stops in a function for
514 which there are no symbols. The prologue scanner will attempt to
515 find the beginning of the function - if the nearest symbol
516 happens to not be aligned on a bundle boundary (16 bytes), the
517 resulting starting address will cause GDB to think that the slot
520 So we warn about it and set the slot number to zero. It is
521 not necessarily a fatal condition, particularly if debugging
522 at the assembly language level. */
525 warning (_("Can't fetch instructions for slot numbers greater than 2.\n"
526 "Using slot 0 instead"));
532 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
537 *instr
= slotN_contents (bundle
, slotnum
);
538 template = extract_bit_field (bundle
, 0, 5);
539 *it
= template_encoding_table
[(int)template][slotnum
];
541 if (slotnum
== 2 || (slotnum
== 1 && *it
== L
))
544 addr
+= (slotnum
+ 1) * SLOT_MULTIPLIER
;
549 /* There are 5 different break instructions (break.i, break.b,
550 break.m, break.f, and break.x), but they all have the same
551 encoding. (The five bit template in the low five bits of the
552 instruction bundle distinguishes one from another.)
554 The runtime architecture manual specifies that break instructions
555 used for debugging purposes must have the upper two bits of the 21
556 bit immediate set to a 0 and a 1 respectively. A breakpoint
557 instruction encodes the most significant bit of its 21 bit
558 immediate at bit 36 of the 41 bit instruction. The penultimate msb
559 is at bit 25 which leads to the pattern below.
561 Originally, I had this set up to do, e.g, a "break.i 0x80000" But
562 it turns out that 0x80000 was used as the syscall break in the early
563 simulators. So I changed the pattern slightly to do "break.i 0x080001"
564 instead. But that didn't work either (I later found out that this
565 pattern was used by the simulator that I was using.) So I ended up
566 using the pattern seen below.
568 SHADOW_CONTENTS has byte-based addressing (PLACED_ADDRESS and SHADOW_LEN)
569 while we need bit-based addressing as the instructions length is 41 bits and
570 we must not modify/corrupt the adjacent slots in the same bundle.
571 Fortunately we may store larger memory incl. the adjacent bits with the
572 original memory content (not the possibly already stored breakpoints there).
573 We need to be careful in ia64_memory_remove_breakpoint to always restore
574 only the specific bits of this instruction ignoring any adjacent stored
577 We use the original addressing with the low nibble in the range <0..2> which
578 gets incorrectly interpreted by generic non-ia64 breakpoint_restore_shadows
579 as the direct byte offset of SHADOW_CONTENTS. We store whole BUNDLE_LEN
580 bytes just without these two possibly skipped bytes to not to exceed to the
583 If we would like to store the whole bundle to SHADOW_CONTENTS we would have
584 to store already the base address (`address & ~0x0f') into PLACED_ADDRESS.
585 In such case there is no other place where to store
586 SLOTNUM (`adress & 0x0f', value in the range <0..2>). We need to know
587 SLOTNUM in ia64_memory_remove_breakpoint.
589 ia64 16-byte bundle layout:
590 | 5 bits | slot 0 with 41 bits | slot 1 with 41 bits | slot 2 with 41 bits |
592 The current addressing used by the code below:
593 original PC placed_address placed_size required covered
594 == bp_tgt->shadow_len reqd \subset covered
595 0xABCDE0 0xABCDE0 0xE <0x0...0x5> <0x0..0xD>
596 0xABCDE1 0xABCDE1 0xE <0x5...0xA> <0x1..0xE>
597 0xABCDE2 0xABCDE2 0xE <0xA...0xF> <0x2..0xF>
599 `objdump -d' and some other tools show a bit unjustified offsets:
600 original PC byte where starts the instruction objdump offset
601 0xABCDE0 0xABCDE0 0xABCDE0
602 0xABCDE1 0xABCDE5 0xABCDE6
603 0xABCDE2 0xABCDEA 0xABCDEC
606 #define IA64_BREAKPOINT 0x00003333300LL
609 ia64_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
610 struct bp_target_info
*bp_tgt
)
612 CORE_ADDR addr
= bp_tgt
->placed_address
;
613 gdb_byte bundle
[BUNDLE_LEN
];
614 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
615 long long instr_breakpoint
;
618 struct cleanup
*cleanup
;
621 error (_("Can't insert breakpoint for slot numbers greater than 2."));
625 /* Enable the automatic memory restoration from breakpoints while
626 we read our instruction bundle for the purpose of SHADOW_CONTENTS.
627 Otherwise, we could possibly store into the shadow parts of the adjacent
628 placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real
629 breakpoint instruction bits region. */
630 cleanup
= make_show_memory_breakpoints_cleanup (0);
631 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
634 do_cleanups (cleanup
);
638 /* Slot number 2 may skip at most 2 bytes at the beginning. */
639 bp_tgt
->shadow_len
= BUNDLE_LEN
- 2;
641 /* Store the whole bundle, except for the initial skipped bytes by the slot
642 number interpreted as bytes offset in PLACED_ADDRESS. */
643 memcpy (bp_tgt
->shadow_contents
, bundle
+ slotnum
, bp_tgt
->shadow_len
);
645 /* Re-read the same bundle as above except that, this time, read it in order
646 to compute the new bundle inside which we will be inserting the
647 breakpoint. Therefore, disable the automatic memory restoration from
648 breakpoints while we read our instruction bundle. Otherwise, the general
649 restoration mechanism kicks in and we would possibly remove parts of the
650 adjacent placed breakpoints. It is due to our SHADOW_CONTENTS overlapping
651 the real breakpoint instruction bits region. */
652 make_show_memory_breakpoints_cleanup (1);
653 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
656 do_cleanups (cleanup
);
660 /* Check for L type instruction in slot 1, if present then bump up the slot
661 number to the slot 2. */
662 template = extract_bit_field (bundle
, 0, 5);
663 if (slotnum
== 1 && template_encoding_table
[template][slotnum
] == L
)
666 /* Breakpoints already present in the code will get deteacted and not get
667 reinserted by bp_loc_is_permanent. Multiple breakpoints at the same
668 location cannot induce the internal error as they are optimized into
669 a single instance by update_global_location_list. */
670 instr_breakpoint
= slotN_contents (bundle
, slotnum
);
671 if (instr_breakpoint
== IA64_BREAKPOINT
)
672 internal_error (__FILE__
, __LINE__
,
673 _("Address %s already contains a breakpoint."),
674 paddress (gdbarch
, bp_tgt
->placed_address
));
675 replace_slotN_contents (bundle
, IA64_BREAKPOINT
, slotnum
);
677 bp_tgt
->placed_size
= bp_tgt
->shadow_len
;
679 val
= target_write_memory (addr
+ slotnum
, bundle
+ slotnum
,
682 do_cleanups (cleanup
);
687 ia64_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
688 struct bp_target_info
*bp_tgt
)
690 CORE_ADDR addr
= bp_tgt
->placed_address
;
691 gdb_byte bundle_mem
[BUNDLE_LEN
], bundle_saved
[BUNDLE_LEN
];
692 int slotnum
= (addr
& 0x0f) / SLOT_MULTIPLIER
;
693 long long instr_breakpoint
, instr_saved
;
696 struct cleanup
*cleanup
;
700 /* Disable the automatic memory restoration from breakpoints while
701 we read our instruction bundle. Otherwise, the general restoration
702 mechanism kicks in and we would possibly remove parts of the adjacent
703 placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real
704 breakpoint instruction bits region. */
705 cleanup
= make_show_memory_breakpoints_cleanup (1);
706 val
= target_read_memory (addr
, bundle_mem
, BUNDLE_LEN
);
709 do_cleanups (cleanup
);
713 /* Check for L type instruction in slot 1, if present then bump up the slot
714 number to the slot 2. */
715 template = extract_bit_field (bundle_mem
, 0, 5);
716 if (slotnum
== 1 && template_encoding_table
[template][slotnum
] == L
)
719 gdb_assert (bp_tgt
->placed_size
== BUNDLE_LEN
- 2);
720 gdb_assert (bp_tgt
->placed_size
== bp_tgt
->shadow_len
);
722 instr_breakpoint
= slotN_contents (bundle_mem
, slotnum
);
723 if (instr_breakpoint
!= IA64_BREAKPOINT
)
725 warning (_("Cannot remove breakpoint at address %s, "
726 "no break instruction at such address."),
727 paddress (gdbarch
, bp_tgt
->placed_address
));
728 do_cleanups (cleanup
);
732 /* Extract the original saved instruction from SLOTNUM normalizing its
733 bit-shift for INSTR_SAVED. */
734 memcpy (bundle_saved
, bundle_mem
, BUNDLE_LEN
);
735 memcpy (bundle_saved
+ slotnum
, bp_tgt
->shadow_contents
, bp_tgt
->shadow_len
);
736 instr_saved
= slotN_contents (bundle_saved
, slotnum
);
738 /* In BUNDLE_MEM be careful to modify only the bits belonging to SLOTNUM and
739 never any other possibly also stored in SHADOW_CONTENTS. */
740 replace_slotN_contents (bundle_mem
, instr_saved
, slotnum
);
741 val
= target_write_memory (addr
, bundle_mem
, BUNDLE_LEN
);
743 do_cleanups (cleanup
);
747 /* As gdbarch_breakpoint_from_pc ranges have byte granularity and ia64
748 instruction slots ranges are bit-granular (41 bits) we have to provide an
749 extended range as described for ia64_memory_insert_breakpoint. We also take
750 care of preserving the `break' instruction 21-bit (or 62-bit) parameter to
751 make a match for permanent breakpoints. */
753 static const gdb_byte
*
754 ia64_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
756 CORE_ADDR addr
= *pcptr
;
757 static gdb_byte bundle
[BUNDLE_LEN
];
758 int slotnum
= (int) (*pcptr
& 0x0f) / SLOT_MULTIPLIER
;
759 long long instr_fetched
;
762 struct cleanup
*cleanup
;
765 error (_("Can't insert breakpoint for slot numbers greater than 2."));
769 /* Enable the automatic memory restoration from breakpoints while
770 we read our instruction bundle to match bp_loc_is_permanent. */
771 cleanup
= make_show_memory_breakpoints_cleanup (0);
772 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
773 do_cleanups (cleanup
);
775 /* The memory might be unreachable. This can happen, for instance,
776 when the user inserts a breakpoint at an invalid address. */
780 /* Check for L type instruction in slot 1, if present then bump up the slot
781 number to the slot 2. */
782 template = extract_bit_field (bundle
, 0, 5);
783 if (slotnum
== 1 && template_encoding_table
[template][slotnum
] == L
)
786 /* A break instruction has its all its opcode bits cleared except for
787 the parameter value. For L+X slot pair we are at the X slot (slot 2) so
788 we should not touch the L slot - the upper 41 bits of the parameter. */
789 instr_fetched
= slotN_contents (bundle
, slotnum
);
790 instr_fetched
&= 0x1003ffffc0LL
;
791 replace_slotN_contents (bundle
, instr_fetched
, slotnum
);
793 *lenptr
= BUNDLE_LEN
- 2;
795 /* SLOTNUM is possibly already locally modified - use caller's *PCPTR. */
796 return bundle
+ (*pcptr
& 0x0f);
800 ia64_read_pc (struct regcache
*regcache
)
802 ULONGEST psr_value
, pc_value
;
805 regcache_cooked_read_unsigned (regcache
, IA64_PSR_REGNUM
, &psr_value
);
806 regcache_cooked_read_unsigned (regcache
, IA64_IP_REGNUM
, &pc_value
);
807 slot_num
= (psr_value
>> 41) & 3;
809 return pc_value
| (slot_num
* SLOT_MULTIPLIER
);
813 ia64_write_pc (struct regcache
*regcache
, CORE_ADDR new_pc
)
815 int slot_num
= (int) (new_pc
& 0xf) / SLOT_MULTIPLIER
;
818 regcache_cooked_read_unsigned (regcache
, IA64_PSR_REGNUM
, &psr_value
);
819 psr_value
&= ~(3LL << 41);
820 psr_value
|= (ULONGEST
)(slot_num
& 0x3) << 41;
824 regcache_cooked_write_unsigned (regcache
, IA64_PSR_REGNUM
, psr_value
);
825 regcache_cooked_write_unsigned (regcache
, IA64_IP_REGNUM
, new_pc
);
828 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
830 /* Returns the address of the slot that's NSLOTS slots away from
831 the address ADDR. NSLOTS may be positive or negative. */
833 rse_address_add(CORE_ADDR addr
, int nslots
)
836 int mandatory_nat_slots
= nslots
/ 63;
837 int direction
= nslots
< 0 ? -1 : 1;
839 new_addr
= addr
+ 8 * (nslots
+ mandatory_nat_slots
);
841 if ((new_addr
>> 9) != ((addr
+ 8 * 64 * mandatory_nat_slots
) >> 9))
842 new_addr
+= 8 * direction
;
844 if (IS_NaT_COLLECTION_ADDR(new_addr
))
845 new_addr
+= 8 * direction
;
851 ia64_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
852 int regnum
, gdb_byte
*buf
)
854 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
856 if (regnum
>= V32_REGNUM
&& regnum
<= V127_REGNUM
)
858 #ifdef HAVE_LIBUNWIND_IA64_H
859 /* First try and use the libunwind special reg accessor, otherwise fallback to
861 if (!libunwind_is_initialized ()
862 || libunwind_get_reg_special (gdbarch
, regcache
, regnum
, buf
) != 0)
865 /* The fallback position is to assume that r32-r127 are found sequentially
866 in memory starting at $bof. This isn't always true, but without libunwind,
867 this is the best we can do. */
871 regcache_cooked_read_unsigned (regcache
, IA64_BSP_REGNUM
, &bsp
);
872 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
874 /* The bsp points at the end of the register frame so we
875 subtract the size of frame from it to get start of register frame. */
876 bsp
= rse_address_add (bsp
, -(cfm
& 0x7f));
878 if ((cfm
& 0x7f) > regnum
- V32_REGNUM
)
880 ULONGEST reg_addr
= rse_address_add (bsp
, (regnum
- V32_REGNUM
));
881 reg
= read_memory_integer ((CORE_ADDR
)reg_addr
, 8, byte_order
);
882 store_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
886 store_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
890 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT31_REGNUM
)
894 regcache_cooked_read_unsigned (regcache
, IA64_UNAT_REGNUM
, &unat
);
895 unatN_val
= (unat
& (1LL << (regnum
- IA64_NAT0_REGNUM
))) != 0;
896 store_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
897 byte_order
, unatN_val
);
899 else if (IA64_NAT32_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
901 ULONGEST natN_val
= 0;
904 CORE_ADDR gr_addr
= 0;
905 regcache_cooked_read_unsigned (regcache
, IA64_BSP_REGNUM
, &bsp
);
906 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
908 /* The bsp points at the end of the register frame so we
909 subtract the size of frame from it to get start of register frame. */
910 bsp
= rse_address_add (bsp
, -(cfm
& 0x7f));
912 if ((cfm
& 0x7f) > regnum
- V32_REGNUM
)
913 gr_addr
= rse_address_add (bsp
, (regnum
- V32_REGNUM
));
917 /* Compute address of nat collection bits. */
918 CORE_ADDR nat_addr
= gr_addr
| 0x1f8;
919 CORE_ADDR nat_collection
;
921 /* If our nat collection address is bigger than bsp, we have to get
922 the nat collection from rnat. Otherwise, we fetch the nat
923 collection from the computed address. */
925 regcache_cooked_read_unsigned (regcache
, IA64_RNAT_REGNUM
, &nat_collection
);
927 nat_collection
= read_memory_integer (nat_addr
, 8, byte_order
);
928 nat_bit
= (gr_addr
>> 3) & 0x3f;
929 natN_val
= (nat_collection
>> nat_bit
) & 1;
932 store_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
933 byte_order
, natN_val
);
935 else if (regnum
== VBOF_REGNUM
)
937 /* A virtual register frame start is provided for user convenience.
938 It can be calculated as the bsp - sof (sizeof frame). */
942 regcache_cooked_read_unsigned (regcache
, IA64_BSP_REGNUM
, &bsp
);
943 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
945 /* The bsp points at the end of the register frame so we
946 subtract the size of frame from it to get beginning of frame. */
947 vbsp
= rse_address_add (bsp
, -(cfm
& 0x7f));
948 store_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
951 else if (VP0_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
957 regcache_cooked_read_unsigned (regcache
, IA64_PR_REGNUM
, &pr
);
958 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
960 if (VP16_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
962 /* Fetch predicate register rename base from current frame
963 marker for this frame. */
964 int rrb_pr
= (cfm
>> 32) & 0x3f;
966 /* Adjust the register number to account for register rotation. */
968 + ((regnum
- VP16_REGNUM
) + rrb_pr
) % 48;
970 prN_val
= (pr
& (1LL << (regnum
- VP0_REGNUM
))) != 0;
971 store_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
972 byte_order
, prN_val
);
975 memset (buf
, 0, register_size (gdbarch
, regnum
));
979 ia64_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
980 int regnum
, const gdb_byte
*buf
)
982 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
984 if (regnum
>= V32_REGNUM
&& regnum
<= V127_REGNUM
)
989 regcache_cooked_read_unsigned (regcache
, IA64_BSP_REGNUM
, &bsp
);
990 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
992 bsp
= rse_address_add (bsp
, -(cfm
& 0x7f));
994 if ((cfm
& 0x7f) > regnum
- V32_REGNUM
)
996 ULONGEST reg_addr
= rse_address_add (bsp
, (regnum
- V32_REGNUM
));
997 write_memory (reg_addr
, (void *)buf
, 8);
1000 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT31_REGNUM
)
1002 ULONGEST unatN_val
, unat
, unatN_mask
;
1003 regcache_cooked_read_unsigned (regcache
, IA64_UNAT_REGNUM
, &unat
);
1004 unatN_val
= extract_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
1006 unatN_mask
= (1LL << (regnum
- IA64_NAT0_REGNUM
));
1008 unat
&= ~unatN_mask
;
1009 else if (unatN_val
== 1)
1011 regcache_cooked_write_unsigned (regcache
, IA64_UNAT_REGNUM
, unat
);
1013 else if (IA64_NAT32_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
1018 CORE_ADDR gr_addr
= 0;
1019 regcache_cooked_read_unsigned (regcache
, IA64_BSP_REGNUM
, &bsp
);
1020 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
1022 /* The bsp points at the end of the register frame so we
1023 subtract the size of frame from it to get start of register frame. */
1024 bsp
= rse_address_add (bsp
, -(cfm
& 0x7f));
1026 if ((cfm
& 0x7f) > regnum
- V32_REGNUM
)
1027 gr_addr
= rse_address_add (bsp
, (regnum
- V32_REGNUM
));
1029 natN_val
= extract_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
1032 if (gr_addr
!= 0 && (natN_val
== 0 || natN_val
== 1))
1034 /* Compute address of nat collection bits. */
1035 CORE_ADDR nat_addr
= gr_addr
| 0x1f8;
1036 CORE_ADDR nat_collection
;
1037 int natN_bit
= (gr_addr
>> 3) & 0x3f;
1038 ULONGEST natN_mask
= (1LL << natN_bit
);
1039 /* If our nat collection address is bigger than bsp, we have to get
1040 the nat collection from rnat. Otherwise, we fetch the nat
1041 collection from the computed address. */
1042 if (nat_addr
>= bsp
)
1044 regcache_cooked_read_unsigned (regcache
, IA64_RNAT_REGNUM
, &nat_collection
);
1046 nat_collection
|= natN_mask
;
1048 nat_collection
&= ~natN_mask
;
1049 regcache_cooked_write_unsigned (regcache
, IA64_RNAT_REGNUM
, nat_collection
);
1054 nat_collection
= read_memory_integer (nat_addr
, 8, byte_order
);
1056 nat_collection
|= natN_mask
;
1058 nat_collection
&= ~natN_mask
;
1059 store_unsigned_integer (nat_buf
, register_size (gdbarch
, regnum
),
1060 byte_order
, nat_collection
);
1061 write_memory (nat_addr
, nat_buf
, 8);
1065 else if (VP0_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
1072 regcache_cooked_read_unsigned (regcache
, IA64_PR_REGNUM
, &pr
);
1073 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
1075 if (VP16_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
1077 /* Fetch predicate register rename base from current frame
1078 marker for this frame. */
1079 int rrb_pr
= (cfm
>> 32) & 0x3f;
1081 /* Adjust the register number to account for register rotation. */
1082 regnum
= VP16_REGNUM
1083 + ((regnum
- VP16_REGNUM
) + rrb_pr
) % 48;
1085 prN_val
= extract_unsigned_integer (buf
, register_size (gdbarch
, regnum
),
1087 prN_mask
= (1LL << (regnum
- VP0_REGNUM
));
1090 else if (prN_val
== 1)
1092 regcache_cooked_write_unsigned (regcache
, IA64_PR_REGNUM
, pr
);
1096 /* The ia64 needs to convert between various ieee floating-point formats
1097 and the special ia64 floating point register format. */
1100 ia64_convert_register_p (struct gdbarch
*gdbarch
, int regno
, struct type
*type
)
1102 return (regno
>= IA64_FR0_REGNUM
&& regno
<= IA64_FR127_REGNUM
1103 && type
!= ia64_ext_type (gdbarch
));
1107 ia64_register_to_value (struct frame_info
*frame
, int regnum
,
1108 struct type
*valtype
, gdb_byte
*out
)
1110 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1111 char in
[MAX_REGISTER_SIZE
];
1112 frame_register_read (frame
, regnum
, in
);
1113 convert_typed_floating (in
, ia64_ext_type (gdbarch
), out
, valtype
);
1117 ia64_value_to_register (struct frame_info
*frame
, int regnum
,
1118 struct type
*valtype
, const gdb_byte
*in
)
1120 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1121 char out
[MAX_REGISTER_SIZE
];
1122 convert_typed_floating (in
, valtype
, out
, ia64_ext_type (gdbarch
));
1123 put_frame_register (frame
, regnum
, out
);
1127 /* Limit the number of skipped non-prologue instructions since examining
1128 of the prologue is expensive. */
1129 static int max_skip_non_prologue_insns
= 40;
1131 /* Given PC representing the starting address of a function, and
1132 LIM_PC which is the (sloppy) limit to which to scan when looking
1133 for a prologue, attempt to further refine this limit by using
1134 the line data in the symbol table. If successful, a better guess
1135 on where the prologue ends is returned, otherwise the previous
1136 value of lim_pc is returned. TRUST_LIMIT is a pointer to a flag
1137 which will be set to indicate whether the returned limit may be
1138 used with no further scanning in the event that the function is
1141 /* FIXME: cagney/2004-02-14: This function and logic have largely been
1142 superseded by skip_prologue_using_sal. */
1145 refine_prologue_limit (CORE_ADDR pc
, CORE_ADDR lim_pc
, int *trust_limit
)
1147 struct symtab_and_line prologue_sal
;
1148 CORE_ADDR start_pc
= pc
;
1151 /* The prologue can not possibly go past the function end itself,
1152 so we can already adjust LIM_PC accordingly. */
1153 if (find_pc_partial_function (pc
, NULL
, NULL
, &end_pc
) && end_pc
< lim_pc
)
1156 /* Start off not trusting the limit. */
1159 prologue_sal
= find_pc_line (pc
, 0);
1160 if (prologue_sal
.line
!= 0)
1163 CORE_ADDR addr
= prologue_sal
.end
;
1165 /* Handle the case in which compiler's optimizer/scheduler
1166 has moved instructions into the prologue. We scan ahead
1167 in the function looking for address ranges whose corresponding
1168 line number is less than or equal to the first one that we
1169 found for the function. (It can be less than when the
1170 scheduler puts a body instruction before the first prologue
1172 for (i
= 2 * max_skip_non_prologue_insns
;
1173 i
> 0 && (lim_pc
== 0 || addr
< lim_pc
);
1176 struct symtab_and_line sal
;
1178 sal
= find_pc_line (addr
, 0);
1181 if (sal
.line
<= prologue_sal
.line
1182 && sal
.symtab
== prologue_sal
.symtab
)
1189 if (lim_pc
== 0 || prologue_sal
.end
< lim_pc
)
1191 lim_pc
= prologue_sal
.end
;
1192 if (start_pc
== get_pc_function_start (lim_pc
))
1199 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
1200 || (8 <= (_regnum_) && (_regnum_) <= 11) \
1201 || (14 <= (_regnum_) && (_regnum_) <= 31))
1202 #define imm9(_instr_) \
1203 ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
1204 | (((_instr_) & 0x00008000000LL) >> 20) \
1205 | (((_instr_) & 0x00000001fc0LL) >> 6))
1207 /* Allocate and initialize a frame cache. */
1209 static struct ia64_frame_cache
*
1210 ia64_alloc_frame_cache (void)
1212 struct ia64_frame_cache
*cache
;
1215 cache
= FRAME_OBSTACK_ZALLOC (struct ia64_frame_cache
);
1221 cache
->prev_cfm
= 0;
1227 cache
->frameless
= 1;
1229 for (i
= 0; i
< NUM_IA64_RAW_REGS
; i
++)
1230 cache
->saved_regs
[i
] = 0;
1236 examine_prologue (CORE_ADDR pc
, CORE_ADDR lim_pc
,
1237 struct frame_info
*this_frame
,
1238 struct ia64_frame_cache
*cache
)
1241 CORE_ADDR last_prologue_pc
= pc
;
1242 instruction_type it
;
1247 int unat_save_reg
= 0;
1248 int pr_save_reg
= 0;
1249 int mem_stack_frame_size
= 0;
1251 CORE_ADDR spill_addr
= 0;
1254 char reg_contents
[256];
1260 CORE_ADDR bof
, sor
, sol
, sof
, cfm
, rrb_gr
;
1262 memset (instores
, 0, sizeof instores
);
1263 memset (infpstores
, 0, sizeof infpstores
);
1264 memset (reg_contents
, 0, sizeof reg_contents
);
1266 if (cache
->after_prologue
!= 0
1267 && cache
->after_prologue
<= lim_pc
)
1268 return cache
->after_prologue
;
1270 lim_pc
= refine_prologue_limit (pc
, lim_pc
, &trust_limit
);
1271 next_pc
= fetch_instruction (pc
, &it
, &instr
);
1273 /* We want to check if we have a recognizable function start before we
1274 look ahead for a prologue. */
1275 if (pc
< lim_pc
&& next_pc
1276 && it
== M
&& ((instr
& 0x1ee0000003fLL
) == 0x02c00000000LL
))
1278 /* alloc - start of a regular function. */
1279 int sor
= (int) ((instr
& 0x00078000000LL
) >> 27);
1280 int sol
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1281 int sof
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1282 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1284 /* Verify that the current cfm matches what we think is the
1285 function start. If we have somehow jumped within a function,
1286 we do not want to interpret the prologue and calculate the
1287 addresses of various registers such as the return address.
1288 We will instead treat the frame as frameless. */
1290 (sof
== (cache
->cfm
& 0x7f) &&
1291 sol
== ((cache
->cfm
>> 7) & 0x7f)))
1295 last_prologue_pc
= next_pc
;
1300 /* Look for a leaf routine. */
1301 if (pc
< lim_pc
&& next_pc
1302 && (it
== I
|| it
== M
)
1303 && ((instr
& 0x1ee00000000LL
) == 0x10800000000LL
))
1305 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
1306 int imm
= (int) ((((instr
& 0x01000000000LL
) ? -1 : 0) << 13)
1307 | ((instr
& 0x001f8000000LL
) >> 20)
1308 | ((instr
& 0x000000fe000LL
) >> 13));
1309 int rM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1310 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1311 int qp
= (int) (instr
& 0x0000000003fLL
);
1312 if (qp
== 0 && rN
== 2 && imm
== 0 && rM
== 12 && fp_reg
== 0)
1314 /* mov r2, r12 - beginning of leaf routine */
1316 last_prologue_pc
= next_pc
;
1320 /* If we don't recognize a regular function or leaf routine, we are
1326 last_prologue_pc
= lim_pc
;
1330 /* Loop, looking for prologue instructions, keeping track of
1331 where preserved registers were spilled. */
1334 next_pc
= fetch_instruction (pc
, &it
, &instr
);
1338 if (it
== B
&& ((instr
& 0x1e1f800003fLL
) != 0x04000000000LL
))
1340 /* Exit loop upon hitting a non-nop branch instruction. */
1345 else if (((instr
& 0x3fLL
) != 0LL) &&
1346 (frameless
|| ret_reg
!= 0))
1348 /* Exit loop upon hitting a predicated instruction if
1349 we already have the return register or if we are frameless. */
1354 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00188000000LL
))
1357 int b2
= (int) ((instr
& 0x0000000e000LL
) >> 13);
1358 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1359 int qp
= (int) (instr
& 0x0000000003f);
1361 if (qp
== 0 && b2
== 0 && rN
>= 32 && ret_reg
== 0)
1364 last_prologue_pc
= next_pc
;
1367 else if ((it
== I
|| it
== M
)
1368 && ((instr
& 0x1ee00000000LL
) == 0x10800000000LL
))
1370 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
1371 int imm
= (int) ((((instr
& 0x01000000000LL
) ? -1 : 0) << 13)
1372 | ((instr
& 0x001f8000000LL
) >> 20)
1373 | ((instr
& 0x000000fe000LL
) >> 13));
1374 int rM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1375 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1376 int qp
= (int) (instr
& 0x0000000003fLL
);
1378 if (qp
== 0 && rN
>= 32 && imm
== 0 && rM
== 12 && fp_reg
== 0)
1382 last_prologue_pc
= next_pc
;
1384 else if (qp
== 0 && rN
== 12 && rM
== 12)
1386 /* adds r12, -mem_stack_frame_size, r12 */
1387 mem_stack_frame_size
-= imm
;
1388 last_prologue_pc
= next_pc
;
1390 else if (qp
== 0 && rN
== 2
1391 && ((rM
== fp_reg
&& fp_reg
!= 0) || rM
== 12))
1393 char buf
[MAX_REGISTER_SIZE
];
1394 CORE_ADDR saved_sp
= 0;
1395 /* adds r2, spilloffset, rFramePointer
1397 adds r2, spilloffset, r12
1399 Get ready for stf.spill or st8.spill instructions.
1400 The address to start spilling at is loaded into r2.
1401 FIXME: Why r2? That's what gcc currently uses; it
1402 could well be different for other compilers. */
1404 /* Hmm... whether or not this will work will depend on
1405 where the pc is. If it's still early in the prologue
1406 this'll be wrong. FIXME */
1409 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1411 get_frame_register (this_frame
, sp_regnum
, buf
);
1412 saved_sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1414 spill_addr
= saved_sp
1415 + (rM
== 12 ? 0 : mem_stack_frame_size
)
1418 last_prologue_pc
= next_pc
;
1420 else if (qp
== 0 && rM
>= 32 && rM
< 40 && !instores
[rM
-32] &&
1421 rN
< 256 && imm
== 0)
1423 /* mov rN, rM where rM is an input register */
1424 reg_contents
[rN
] = rM
;
1425 last_prologue_pc
= next_pc
;
1427 else if (frameless
&& qp
== 0 && rN
== fp_reg
&& imm
== 0 &&
1431 last_prologue_pc
= next_pc
;
1436 && ( ((instr
& 0x1efc0000000LL
) == 0x0eec0000000LL
)
1437 || ((instr
& 0x1ffc8000000LL
) == 0x0cec0000000LL
) ))
1439 /* stf.spill [rN] = fM, imm9
1441 stf.spill [rN] = fM */
1443 int imm
= imm9(instr
);
1444 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1445 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1446 int qp
= (int) (instr
& 0x0000000003fLL
);
1447 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
1448 && ((2 <= fM
&& fM
<= 5) || (16 <= fM
&& fM
<= 31)))
1450 cache
->saved_regs
[IA64_FR0_REGNUM
+ fM
] = spill_addr
;
1452 if ((instr
& 0x1efc0000000LL
) == 0x0eec0000000LL
)
1455 spill_addr
= 0; /* last one; must be done */
1456 last_prologue_pc
= next_pc
;
1459 else if ((it
== M
&& ((instr
& 0x1eff8000000LL
) == 0x02110000000LL
))
1460 || (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00050000000LL
)) )
1466 int arM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1467 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1468 int qp
= (int) (instr
& 0x0000000003fLL
);
1469 if (qp
== 0 && isScratch (rN
) && arM
== 36 /* ar.unat */)
1471 /* We have something like "mov.m r3 = ar.unat". Remember the
1472 r3 (or whatever) and watch for a store of this register... */
1474 last_prologue_pc
= next_pc
;
1477 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00198000000LL
))
1480 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1481 int qp
= (int) (instr
& 0x0000000003fLL
);
1482 if (qp
== 0 && isScratch (rN
))
1485 last_prologue_pc
= next_pc
;
1489 && ( ((instr
& 0x1ffc8000000LL
) == 0x08cc0000000LL
)
1490 || ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)))
1494 st8 [rN] = rM, imm9 */
1495 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1496 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1497 int qp
= (int) (instr
& 0x0000000003fLL
);
1498 int indirect
= rM
< 256 ? reg_contents
[rM
] : 0;
1499 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
1500 && (rM
== unat_save_reg
|| rM
== pr_save_reg
))
1502 /* We've found a spill of either the UNAT register or the PR
1503 register. (Well, not exactly; what we've actually found is
1504 a spill of the register that UNAT or PR was moved to).
1505 Record that fact and move on... */
1506 if (rM
== unat_save_reg
)
1508 /* Track UNAT register */
1509 cache
->saved_regs
[IA64_UNAT_REGNUM
] = spill_addr
;
1514 /* Track PR register */
1515 cache
->saved_regs
[IA64_PR_REGNUM
] = spill_addr
;
1518 if ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)
1519 /* st8 [rN] = rM, imm9 */
1520 spill_addr
+= imm9(instr
);
1522 spill_addr
= 0; /* must be done spilling */
1523 last_prologue_pc
= next_pc
;
1525 else if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1527 /* Allow up to one store of each input register. */
1528 instores
[rM
-32] = 1;
1529 last_prologue_pc
= next_pc
;
1531 else if (qp
== 0 && 32 <= indirect
&& indirect
< 40 &&
1532 !instores
[indirect
-32])
1534 /* Allow an indirect store of an input register. */
1535 instores
[indirect
-32] = 1;
1536 last_prologue_pc
= next_pc
;
1539 else if (it
== M
&& ((instr
& 0x1ff08000000LL
) == 0x08c00000000LL
))
1546 Note that the st8 case is handled in the clause above.
1548 Advance over stores of input registers. One store per input
1549 register is permitted. */
1550 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1551 int qp
= (int) (instr
& 0x0000000003fLL
);
1552 int indirect
= rM
< 256 ? reg_contents
[rM
] : 0;
1553 if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1555 instores
[rM
-32] = 1;
1556 last_prologue_pc
= next_pc
;
1558 else if (qp
== 0 && 32 <= indirect
&& indirect
< 40 &&
1559 !instores
[indirect
-32])
1561 /* Allow an indirect store of an input register. */
1562 instores
[indirect
-32] = 1;
1563 last_prologue_pc
= next_pc
;
1566 else if (it
== M
&& ((instr
& 0x1ff88000000LL
) == 0x0cc80000000LL
))
1573 Advance over stores of floating point input registers. Again
1574 one store per register is permitted */
1575 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1576 int qp
= (int) (instr
& 0x0000000003fLL
);
1577 if (qp
== 0 && 8 <= fM
&& fM
< 16 && !infpstores
[fM
- 8])
1579 infpstores
[fM
-8] = 1;
1580 last_prologue_pc
= next_pc
;
1584 && ( ((instr
& 0x1ffc8000000LL
) == 0x08ec0000000LL
)
1585 || ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)))
1587 /* st8.spill [rN] = rM
1589 st8.spill [rN] = rM, imm9 */
1590 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1591 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1592 int qp
= (int) (instr
& 0x0000000003fLL
);
1593 if (qp
== 0 && rN
== spill_reg
&& 4 <= rM
&& rM
<= 7)
1595 /* We've found a spill of one of the preserved general purpose
1596 regs. Record the spill address and advance the spill
1597 register if appropriate. */
1598 cache
->saved_regs
[IA64_GR0_REGNUM
+ rM
] = spill_addr
;
1599 if ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)
1600 /* st8.spill [rN] = rM, imm9 */
1601 spill_addr
+= imm9(instr
);
1603 spill_addr
= 0; /* Done spilling */
1604 last_prologue_pc
= next_pc
;
1611 /* If not frameless and we aren't called by skip_prologue, then we need
1612 to calculate registers for the previous frame which will be needed
1615 if (!frameless
&& this_frame
)
1617 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1618 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1620 /* Extract the size of the rotating portion of the stack
1621 frame and the register rename base from the current
1627 rrb_gr
= (cfm
>> 18) & 0x7f;
1629 /* Find the bof (beginning of frame). */
1630 bof
= rse_address_add (cache
->bsp
, -sof
);
1632 for (i
= 0, addr
= bof
;
1636 if (IS_NaT_COLLECTION_ADDR (addr
))
1640 if (i
+32 == cfm_reg
)
1641 cache
->saved_regs
[IA64_CFM_REGNUM
] = addr
;
1642 if (i
+32 == ret_reg
)
1643 cache
->saved_regs
[IA64_VRAP_REGNUM
] = addr
;
1645 cache
->saved_regs
[IA64_VFP_REGNUM
] = addr
;
1648 /* For the previous argument registers we require the previous bof.
1649 If we can't find the previous cfm, then we can do nothing. */
1651 if (cache
->saved_regs
[IA64_CFM_REGNUM
] != 0)
1653 cfm
= read_memory_integer (cache
->saved_regs
[IA64_CFM_REGNUM
],
1656 else if (cfm_reg
!= 0)
1658 get_frame_register (this_frame
, cfm_reg
, buf
);
1659 cfm
= extract_unsigned_integer (buf
, 8, byte_order
);
1661 cache
->prev_cfm
= cfm
;
1665 sor
= ((cfm
>> 14) & 0xf) * 8;
1667 sol
= (cfm
>> 7) & 0x7f;
1668 rrb_gr
= (cfm
>> 18) & 0x7f;
1670 /* The previous bof only requires subtraction of the sol (size of
1671 locals) due to the overlap between output and input of
1672 subsequent frames. */
1673 bof
= rse_address_add (bof
, -sol
);
1675 for (i
= 0, addr
= bof
;
1679 if (IS_NaT_COLLECTION_ADDR (addr
))
1684 cache
->saved_regs
[IA64_GR32_REGNUM
+ ((i
+ (sor
- rrb_gr
)) % sor
)]
1687 cache
->saved_regs
[IA64_GR32_REGNUM
+ i
] = addr
;
1693 /* Try and trust the lim_pc value whenever possible. */
1694 if (trust_limit
&& lim_pc
>= last_prologue_pc
)
1695 last_prologue_pc
= lim_pc
;
1697 cache
->frameless
= frameless
;
1698 cache
->after_prologue
= last_prologue_pc
;
1699 cache
->mem_stack_frame_size
= mem_stack_frame_size
;
1700 cache
->fp_reg
= fp_reg
;
1702 return last_prologue_pc
;
1706 ia64_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1708 struct ia64_frame_cache cache
;
1710 cache
.after_prologue
= 0;
1714 /* Call examine_prologue with - as third argument since we don't have a next frame pointer to send. */
1715 return examine_prologue (pc
, pc
+1024, 0, &cache
);
1719 /* Normal frames. */
1721 static struct ia64_frame_cache
*
1722 ia64_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1724 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1725 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1726 struct ia64_frame_cache
*cache
;
1728 CORE_ADDR cfm
, sof
, sol
, bsp
, psr
;
1734 cache
= ia64_alloc_frame_cache ();
1735 *this_cache
= cache
;
1737 get_frame_register (this_frame
, sp_regnum
, buf
);
1738 cache
->saved_sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1740 /* We always want the bsp to point to the end of frame.
1741 This way, we can always get the beginning of frame (bof)
1742 by subtracting frame size. */
1743 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
1744 cache
->bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
1746 get_frame_register (this_frame
, IA64_PSR_REGNUM
, buf
);
1747 psr
= extract_unsigned_integer (buf
, 8, byte_order
);
1749 get_frame_register (this_frame
, IA64_CFM_REGNUM
, buf
);
1750 cfm
= extract_unsigned_integer (buf
, 8, byte_order
);
1752 cache
->sof
= (cfm
& 0x7f);
1753 cache
->sol
= (cfm
>> 7) & 0x7f;
1754 cache
->sor
= ((cfm
>> 14) & 0xf) * 8;
1758 cache
->pc
= get_frame_func (this_frame
);
1761 examine_prologue (cache
->pc
, get_frame_pc (this_frame
), this_frame
, cache
);
1763 cache
->base
= cache
->saved_sp
+ cache
->mem_stack_frame_size
;
1769 ia64_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1770 struct frame_id
*this_id
)
1772 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1773 struct ia64_frame_cache
*cache
=
1774 ia64_frame_cache (this_frame
, this_cache
);
1776 /* If outermost frame, mark with null frame id. */
1777 if (cache
->base
== 0)
1778 (*this_id
) = null_frame_id
;
1780 (*this_id
) = frame_id_build_special (cache
->base
, cache
->pc
, cache
->bsp
);
1781 if (gdbarch_debug
>= 1)
1782 fprintf_unfiltered (gdb_stdlog
,
1783 "regular frame id: code %s, stack %s, special %s, this_frame %s\n",
1784 paddress (gdbarch
, this_id
->code_addr
),
1785 paddress (gdbarch
, this_id
->stack_addr
),
1786 paddress (gdbarch
, cache
->bsp
),
1787 host_address_to_string (this_frame
));
1790 static struct value
*
1791 ia64_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1794 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1795 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1796 struct ia64_frame_cache
*cache
= ia64_frame_cache (this_frame
, this_cache
);
1799 gdb_assert (regnum
>= 0);
1801 if (!target_has_registers
)
1802 error (_("No registers."));
1804 if (regnum
== gdbarch_sp_regnum (gdbarch
))
1805 return frame_unwind_got_constant (this_frame
, regnum
, cache
->base
);
1807 else if (regnum
== IA64_BSP_REGNUM
)
1810 CORE_ADDR prev_cfm
, bsp
, prev_bsp
;
1812 /* We want to calculate the previous bsp as the end of the previous
1813 register stack frame. This corresponds to what the hardware bsp
1814 register will be if we pop the frame back which is why we might
1815 have been called. We know the beginning of the current frame is
1816 cache->bsp - cache->sof. This value in the previous frame points
1817 to the start of the output registers. We can calculate the end of
1818 that frame by adding the size of output:
1819 (sof (size of frame) - sol (size of locals)). */
1820 val
= ia64_frame_prev_register (this_frame
, this_cache
, IA64_CFM_REGNUM
);
1821 prev_cfm
= extract_unsigned_integer (value_contents_all (val
),
1823 bsp
= rse_address_add (cache
->bsp
, -(cache
->sof
));
1825 rse_address_add (bsp
, (prev_cfm
& 0x7f) - ((prev_cfm
>> 7) & 0x7f));
1827 return frame_unwind_got_constant (this_frame
, regnum
, prev_bsp
);
1830 else if (regnum
== IA64_CFM_REGNUM
)
1832 CORE_ADDR addr
= cache
->saved_regs
[IA64_CFM_REGNUM
];
1835 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1837 if (cache
->prev_cfm
)
1838 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_cfm
);
1840 if (cache
->frameless
)
1841 return frame_unwind_got_register (this_frame
, IA64_PFS_REGNUM
,
1843 return frame_unwind_got_register (this_frame
, regnum
, 0);
1846 else if (regnum
== IA64_VFP_REGNUM
)
1848 /* If the function in question uses an automatic register (r32-r127)
1849 for the frame pointer, it'll be found by ia64_find_saved_register()
1850 above. If the function lacks one of these frame pointers, we can
1851 still provide a value since we know the size of the frame. */
1852 return frame_unwind_got_constant (this_frame
, regnum
, cache
->base
);
1855 else if (VP0_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
1857 struct value
*pr_val
;
1860 pr_val
= ia64_frame_prev_register (this_frame
, this_cache
,
1862 if (VP16_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
1864 /* Fetch predicate register rename base from current frame
1865 marker for this frame. */
1866 int rrb_pr
= (cache
->cfm
>> 32) & 0x3f;
1868 /* Adjust the register number to account for register rotation. */
1869 regnum
= VP16_REGNUM
+ ((regnum
- VP16_REGNUM
) + rrb_pr
) % 48;
1871 prN
= extract_bit_field (value_contents_all (pr_val
),
1872 regnum
- VP0_REGNUM
, 1);
1873 return frame_unwind_got_constant (this_frame
, regnum
, prN
);
1876 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT31_REGNUM
)
1878 struct value
*unat_val
;
1880 unat_val
= ia64_frame_prev_register (this_frame
, this_cache
,
1882 unatN
= extract_bit_field (value_contents_all (unat_val
),
1883 regnum
- IA64_NAT0_REGNUM
, 1);
1884 return frame_unwind_got_constant (this_frame
, regnum
, unatN
);
1887 else if (IA64_NAT32_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
1890 /* Find address of general register corresponding to nat bit we're
1894 gr_addr
= cache
->saved_regs
[regnum
- IA64_NAT0_REGNUM
+ IA64_GR0_REGNUM
];
1898 /* Compute address of nat collection bits. */
1899 CORE_ADDR nat_addr
= gr_addr
| 0x1f8;
1901 CORE_ADDR nat_collection
;
1904 /* If our nat collection address is bigger than bsp, we have to get
1905 the nat collection from rnat. Otherwise, we fetch the nat
1906 collection from the computed address. */
1907 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
1908 bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
1909 if (nat_addr
>= bsp
)
1911 get_frame_register (this_frame
, IA64_RNAT_REGNUM
, buf
);
1912 nat_collection
= extract_unsigned_integer (buf
, 8, byte_order
);
1915 nat_collection
= read_memory_integer (nat_addr
, 8, byte_order
);
1916 nat_bit
= (gr_addr
>> 3) & 0x3f;
1917 natval
= (nat_collection
>> nat_bit
) & 1;
1920 return frame_unwind_got_constant (this_frame
, regnum
, natval
);
1923 else if (regnum
== IA64_IP_REGNUM
)
1926 CORE_ADDR addr
= cache
->saved_regs
[IA64_VRAP_REGNUM
];
1930 read_memory (addr
, buf
, register_size (gdbarch
, IA64_IP_REGNUM
));
1931 pc
= extract_unsigned_integer (buf
, 8, byte_order
);
1933 else if (cache
->frameless
)
1935 get_frame_register (this_frame
, IA64_BR0_REGNUM
, buf
);
1936 pc
= extract_unsigned_integer (buf
, 8, byte_order
);
1939 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1942 else if (regnum
== IA64_PSR_REGNUM
)
1944 /* We don't know how to get the complete previous PSR, but we need it
1945 for the slot information when we unwind the pc (pc is formed of IP
1946 register plus slot information from PSR). To get the previous
1947 slot information, we mask it off the return address. */
1948 ULONGEST slot_num
= 0;
1951 CORE_ADDR addr
= cache
->saved_regs
[IA64_VRAP_REGNUM
];
1953 get_frame_register (this_frame
, IA64_PSR_REGNUM
, buf
);
1954 psr
= extract_unsigned_integer (buf
, 8, byte_order
);
1958 read_memory (addr
, buf
, register_size (gdbarch
, IA64_IP_REGNUM
));
1959 pc
= extract_unsigned_integer (buf
, 8, byte_order
);
1961 else if (cache
->frameless
)
1963 get_frame_register (this_frame
, IA64_BR0_REGNUM
, buf
);
1964 pc
= extract_unsigned_integer (buf
, 8, byte_order
);
1966 psr
&= ~(3LL << 41);
1967 slot_num
= pc
& 0x3LL
;
1968 psr
|= (CORE_ADDR
)slot_num
<< 41;
1969 return frame_unwind_got_constant (this_frame
, regnum
, psr
);
1972 else if (regnum
== IA64_BR0_REGNUM
)
1974 CORE_ADDR addr
= cache
->saved_regs
[IA64_BR0_REGNUM
];
1977 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1979 return frame_unwind_got_constant (this_frame
, regnum
, 0);
1982 else if ((regnum
>= IA64_GR32_REGNUM
&& regnum
<= IA64_GR127_REGNUM
)
1983 || (regnum
>= V32_REGNUM
&& regnum
<= V127_REGNUM
))
1987 if (regnum
>= V32_REGNUM
)
1988 regnum
= IA64_GR32_REGNUM
+ (regnum
- V32_REGNUM
);
1989 addr
= cache
->saved_regs
[regnum
];
1991 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1993 if (cache
->frameless
)
1995 struct value
*reg_val
;
1996 CORE_ADDR prev_cfm
, prev_bsp
, prev_bof
;
1998 /* FIXME: brobecker/2008-05-01: Doesn't this seem redundant
1999 with the same code above? */
2000 if (regnum
>= V32_REGNUM
)
2001 regnum
= IA64_GR32_REGNUM
+ (regnum
- V32_REGNUM
);
2002 reg_val
= ia64_frame_prev_register (this_frame
, this_cache
,
2004 prev_cfm
= extract_unsigned_integer (value_contents_all (reg_val
),
2006 reg_val
= ia64_frame_prev_register (this_frame
, this_cache
,
2008 prev_bsp
= extract_unsigned_integer (value_contents_all (reg_val
),
2010 prev_bof
= rse_address_add (prev_bsp
, -(prev_cfm
& 0x7f));
2012 addr
= rse_address_add (prev_bof
, (regnum
- IA64_GR32_REGNUM
));
2013 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
2016 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2019 else /* All other registers. */
2023 if (IA64_FR32_REGNUM
<= regnum
&& regnum
<= IA64_FR127_REGNUM
)
2025 /* Fetch floating point register rename base from current
2026 frame marker for this frame. */
2027 int rrb_fr
= (cache
->cfm
>> 25) & 0x7f;
2029 /* Adjust the floating point register number to account for
2030 register rotation. */
2031 regnum
= IA64_FR32_REGNUM
2032 + ((regnum
- IA64_FR32_REGNUM
) + rrb_fr
) % 96;
2035 /* If we have stored a memory address, access the register. */
2036 addr
= cache
->saved_regs
[regnum
];
2038 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
2039 /* Otherwise, punt and get the current value of the register. */
2041 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
2045 static const struct frame_unwind ia64_frame_unwind
=
2048 &ia64_frame_this_id
,
2049 &ia64_frame_prev_register
,
2051 default_frame_sniffer
2054 /* Signal trampolines. */
2057 ia64_sigtramp_frame_init_saved_regs (struct frame_info
*this_frame
,
2058 struct ia64_frame_cache
*cache
)
2060 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2061 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2063 if (tdep
->sigcontext_register_address
)
2067 cache
->saved_regs
[IA64_VRAP_REGNUM
] =
2068 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_IP_REGNUM
);
2069 cache
->saved_regs
[IA64_CFM_REGNUM
] =
2070 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_CFM_REGNUM
);
2071 cache
->saved_regs
[IA64_PSR_REGNUM
] =
2072 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_PSR_REGNUM
);
2073 cache
->saved_regs
[IA64_BSP_REGNUM
] =
2074 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_BSP_REGNUM
);
2075 cache
->saved_regs
[IA64_RNAT_REGNUM
] =
2076 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_RNAT_REGNUM
);
2077 cache
->saved_regs
[IA64_CCV_REGNUM
] =
2078 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_CCV_REGNUM
);
2079 cache
->saved_regs
[IA64_UNAT_REGNUM
] =
2080 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_UNAT_REGNUM
);
2081 cache
->saved_regs
[IA64_FPSR_REGNUM
] =
2082 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_FPSR_REGNUM
);
2083 cache
->saved_regs
[IA64_PFS_REGNUM
] =
2084 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_PFS_REGNUM
);
2085 cache
->saved_regs
[IA64_LC_REGNUM
] =
2086 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, IA64_LC_REGNUM
);
2087 for (regno
= IA64_GR1_REGNUM
; regno
<= IA64_GR31_REGNUM
; regno
++)
2088 cache
->saved_regs
[regno
] =
2089 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, regno
);
2090 for (regno
= IA64_BR0_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
2091 cache
->saved_regs
[regno
] =
2092 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, regno
);
2093 for (regno
= IA64_FR2_REGNUM
; regno
<= IA64_FR31_REGNUM
; regno
++)
2094 cache
->saved_regs
[regno
] =
2095 tdep
->sigcontext_register_address (gdbarch
, cache
->base
, regno
);
2099 static struct ia64_frame_cache
*
2100 ia64_sigtramp_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2102 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2103 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2104 struct ia64_frame_cache
*cache
;
2112 cache
= ia64_alloc_frame_cache ();
2114 get_frame_register (this_frame
, sp_regnum
, buf
);
2115 /* Note that frame size is hard-coded below. We cannot calculate it
2116 via prologue examination. */
2117 cache
->base
= extract_unsigned_integer (buf
, 8, byte_order
) + 16;
2119 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
2120 cache
->bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
2122 get_frame_register (this_frame
, IA64_CFM_REGNUM
, buf
);
2123 cache
->cfm
= extract_unsigned_integer (buf
, 8, byte_order
);
2124 cache
->sof
= cache
->cfm
& 0x7f;
2126 ia64_sigtramp_frame_init_saved_regs (this_frame
, cache
);
2128 *this_cache
= cache
;
2133 ia64_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2134 void **this_cache
, struct frame_id
*this_id
)
2136 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2137 struct ia64_frame_cache
*cache
=
2138 ia64_sigtramp_frame_cache (this_frame
, this_cache
);
2140 (*this_id
) = frame_id_build_special (cache
->base
,
2141 get_frame_pc (this_frame
),
2143 if (gdbarch_debug
>= 1)
2144 fprintf_unfiltered (gdb_stdlog
,
2145 "sigtramp frame id: code %s, stack %s, special %s, this_frame %s\n",
2146 paddress (gdbarch
, this_id
->code_addr
),
2147 paddress (gdbarch
, this_id
->stack_addr
),
2148 paddress (gdbarch
, cache
->bsp
),
2149 host_address_to_string (this_frame
));
2152 static struct value
*
2153 ia64_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2154 void **this_cache
, int regnum
)
2156 char buf
[MAX_REGISTER_SIZE
];
2158 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2159 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2160 struct ia64_frame_cache
*cache
=
2161 ia64_sigtramp_frame_cache (this_frame
, this_cache
);
2163 gdb_assert (regnum
>= 0);
2165 if (!target_has_registers
)
2166 error (_("No registers."));
2168 if (regnum
== IA64_IP_REGNUM
)
2171 CORE_ADDR addr
= cache
->saved_regs
[IA64_VRAP_REGNUM
];
2175 read_memory (addr
, buf
, register_size (gdbarch
, IA64_IP_REGNUM
));
2176 pc
= extract_unsigned_integer (buf
, 8, byte_order
);
2179 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
2182 else if ((regnum
>= IA64_GR32_REGNUM
&& regnum
<= IA64_GR127_REGNUM
)
2183 || (regnum
>= V32_REGNUM
&& regnum
<= V127_REGNUM
))
2187 if (regnum
>= V32_REGNUM
)
2188 regnum
= IA64_GR32_REGNUM
+ (regnum
- V32_REGNUM
);
2189 addr
= cache
->saved_regs
[regnum
];
2191 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
2193 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2196 else /* All other registers not listed above. */
2198 CORE_ADDR addr
= cache
->saved_regs
[regnum
];
2201 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
2203 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2208 ia64_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2209 struct frame_info
*this_frame
,
2212 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (this_frame
));
2213 if (tdep
->pc_in_sigtramp
)
2215 CORE_ADDR pc
= get_frame_pc (this_frame
);
2217 if (tdep
->pc_in_sigtramp (pc
))
2224 static const struct frame_unwind ia64_sigtramp_frame_unwind
=
2227 ia64_sigtramp_frame_this_id
,
2228 ia64_sigtramp_frame_prev_register
,
2230 ia64_sigtramp_frame_sniffer
2236 ia64_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2238 struct ia64_frame_cache
*cache
= ia64_frame_cache (this_frame
, this_cache
);
2243 static const struct frame_base ia64_frame_base
=
2246 ia64_frame_base_address
,
2247 ia64_frame_base_address
,
2248 ia64_frame_base_address
2251 #ifdef HAVE_LIBUNWIND_IA64_H
2253 struct ia64_unwind_table_entry
2255 unw_word_t start_offset
;
2256 unw_word_t end_offset
;
2257 unw_word_t info_offset
;
2260 static __inline__
uint64_t
2261 ia64_rse_slot_num (uint64_t addr
)
2263 return (addr
>> 3) & 0x3f;
2266 /* Skip over a designated number of registers in the backing
2267 store, remembering every 64th position is for NAT. */
2268 static __inline__
uint64_t
2269 ia64_rse_skip_regs (uint64_t addr
, long num_regs
)
2271 long delta
= ia64_rse_slot_num(addr
) + num_regs
;
2275 return addr
+ ((num_regs
+ delta
/0x3f) << 3);
2278 /* Gdb libunwind-frame callback function to convert from an ia64 gdb register
2279 number to a libunwind register number. */
2281 ia64_gdb2uw_regnum (int regnum
)
2283 if (regnum
== sp_regnum
)
2285 else if (regnum
== IA64_BSP_REGNUM
)
2286 return UNW_IA64_BSP
;
2287 else if ((unsigned) (regnum
- IA64_GR0_REGNUM
) < 128)
2288 return UNW_IA64_GR
+ (regnum
- IA64_GR0_REGNUM
);
2289 else if ((unsigned) (regnum
- V32_REGNUM
) < 95)
2290 return UNW_IA64_GR
+ 32 + (regnum
- V32_REGNUM
);
2291 else if ((unsigned) (regnum
- IA64_FR0_REGNUM
) < 128)
2292 return UNW_IA64_FR
+ (regnum
- IA64_FR0_REGNUM
);
2293 else if ((unsigned) (regnum
- IA64_PR0_REGNUM
) < 64)
2295 else if ((unsigned) (regnum
- IA64_BR0_REGNUM
) < 8)
2296 return UNW_IA64_BR
+ (regnum
- IA64_BR0_REGNUM
);
2297 else if (regnum
== IA64_PR_REGNUM
)
2299 else if (regnum
== IA64_IP_REGNUM
)
2301 else if (regnum
== IA64_CFM_REGNUM
)
2302 return UNW_IA64_CFM
;
2303 else if ((unsigned) (regnum
- IA64_AR0_REGNUM
) < 128)
2304 return UNW_IA64_AR
+ (regnum
- IA64_AR0_REGNUM
);
2305 else if ((unsigned) (regnum
- IA64_NAT0_REGNUM
) < 128)
2306 return UNW_IA64_NAT
+ (regnum
- IA64_NAT0_REGNUM
);
2311 /* Gdb libunwind-frame callback function to convert from a libunwind register
2312 number to a ia64 gdb register number. */
2314 ia64_uw2gdb_regnum (int uw_regnum
)
2316 if (uw_regnum
== UNW_IA64_SP
)
2318 else if (uw_regnum
== UNW_IA64_BSP
)
2319 return IA64_BSP_REGNUM
;
2320 else if ((unsigned) (uw_regnum
- UNW_IA64_GR
) < 32)
2321 return IA64_GR0_REGNUM
+ (uw_regnum
- UNW_IA64_GR
);
2322 else if ((unsigned) (uw_regnum
- UNW_IA64_GR
) < 128)
2323 return V32_REGNUM
+ (uw_regnum
- (IA64_GR0_REGNUM
+ 32));
2324 else if ((unsigned) (uw_regnum
- UNW_IA64_FR
) < 128)
2325 return IA64_FR0_REGNUM
+ (uw_regnum
- UNW_IA64_FR
);
2326 else if ((unsigned) (uw_regnum
- UNW_IA64_BR
) < 8)
2327 return IA64_BR0_REGNUM
+ (uw_regnum
- UNW_IA64_BR
);
2328 else if (uw_regnum
== UNW_IA64_PR
)
2329 return IA64_PR_REGNUM
;
2330 else if (uw_regnum
== UNW_REG_IP
)
2331 return IA64_IP_REGNUM
;
2332 else if (uw_regnum
== UNW_IA64_CFM
)
2333 return IA64_CFM_REGNUM
;
2334 else if ((unsigned) (uw_regnum
- UNW_IA64_AR
) < 128)
2335 return IA64_AR0_REGNUM
+ (uw_regnum
- UNW_IA64_AR
);
2336 else if ((unsigned) (uw_regnum
- UNW_IA64_NAT
) < 128)
2337 return IA64_NAT0_REGNUM
+ (uw_regnum
- UNW_IA64_NAT
);
2342 /* Gdb libunwind-frame callback function to reveal if register is a float
2345 ia64_is_fpreg (int uw_regnum
)
2347 return unw_is_fpreg (uw_regnum
);
2350 /* Libunwind callback accessor function for general registers. */
2352 ia64_access_reg (unw_addr_space_t as
, unw_regnum_t uw_regnum
, unw_word_t
*val
,
2353 int write
, void *arg
)
2355 int regnum
= ia64_uw2gdb_regnum (uw_regnum
);
2356 unw_word_t bsp
, sof
, sol
, cfm
, psr
, ip
;
2357 struct frame_info
*this_frame
= arg
;
2358 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2359 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2360 long new_sof
, old_sof
;
2361 char buf
[MAX_REGISTER_SIZE
];
2363 /* We never call any libunwind routines that need to write registers. */
2364 gdb_assert (!write
);
2369 /* Libunwind expects to see the pc value which means the slot number
2370 from the psr must be merged with the ip word address. */
2371 get_frame_register (this_frame
, IA64_IP_REGNUM
, buf
);
2372 ip
= extract_unsigned_integer (buf
, 8, byte_order
);
2373 get_frame_register (this_frame
, IA64_PSR_REGNUM
, buf
);
2374 psr
= extract_unsigned_integer (buf
, 8, byte_order
);
2375 *val
= ip
| ((psr
>> 41) & 0x3);
2378 case UNW_IA64_AR_BSP
:
2379 /* Libunwind expects to see the beginning of the current register
2380 frame so we must account for the fact that ptrace() will return a value
2381 for bsp that points *after* the current register frame. */
2382 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
2383 bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
2384 get_frame_register (this_frame
, IA64_CFM_REGNUM
, buf
);
2385 cfm
= extract_unsigned_integer (buf
, 8, byte_order
);
2387 *val
= ia64_rse_skip_regs (bsp
, -sof
);
2390 case UNW_IA64_AR_BSPSTORE
:
2391 /* Libunwind wants bspstore to be after the current register frame.
2392 This is what ptrace() and gdb treats as the regular bsp value. */
2393 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
2394 *val
= extract_unsigned_integer (buf
, 8, byte_order
);
2398 /* For all other registers, just unwind the value directly. */
2399 get_frame_register (this_frame
, regnum
, buf
);
2400 *val
= extract_unsigned_integer (buf
, 8, byte_order
);
2404 if (gdbarch_debug
>= 1)
2405 fprintf_unfiltered (gdb_stdlog
,
2406 " access_reg: from cache: %4s=%s\n",
2407 (((unsigned) regnum
<= IA64_NAT127_REGNUM
)
2408 ? ia64_register_names
[regnum
] : "r??"),
2409 paddress (gdbarch
, *val
));
2413 /* Libunwind callback accessor function for floating-point registers. */
2415 ia64_access_fpreg (unw_addr_space_t as
, unw_regnum_t uw_regnum
, unw_fpreg_t
*val
,
2416 int write
, void *arg
)
2418 int regnum
= ia64_uw2gdb_regnum (uw_regnum
);
2419 struct frame_info
*this_frame
= arg
;
2421 /* We never call any libunwind routines that need to write registers. */
2422 gdb_assert (!write
);
2424 get_frame_register (this_frame
, regnum
, (char *) val
);
2429 /* Libunwind callback accessor function for top-level rse registers. */
2431 ia64_access_rse_reg (unw_addr_space_t as
, unw_regnum_t uw_regnum
, unw_word_t
*val
,
2432 int write
, void *arg
)
2434 int regnum
= ia64_uw2gdb_regnum (uw_regnum
);
2435 unw_word_t bsp
, sof
, sol
, cfm
, psr
, ip
;
2436 struct regcache
*regcache
= arg
;
2437 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2438 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2439 long new_sof
, old_sof
;
2440 char buf
[MAX_REGISTER_SIZE
];
2442 /* We never call any libunwind routines that need to write registers. */
2443 gdb_assert (!write
);
2448 /* Libunwind expects to see the pc value which means the slot number
2449 from the psr must be merged with the ip word address. */
2450 regcache_cooked_read (regcache
, IA64_IP_REGNUM
, buf
);
2451 ip
= extract_unsigned_integer (buf
, 8, byte_order
);
2452 regcache_cooked_read (regcache
, IA64_PSR_REGNUM
, buf
);
2453 psr
= extract_unsigned_integer (buf
, 8, byte_order
);
2454 *val
= ip
| ((psr
>> 41) & 0x3);
2457 case UNW_IA64_AR_BSP
:
2458 /* Libunwind expects to see the beginning of the current register
2459 frame so we must account for the fact that ptrace() will return a value
2460 for bsp that points *after* the current register frame. */
2461 regcache_cooked_read (regcache
, IA64_BSP_REGNUM
, buf
);
2462 bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
2463 regcache_cooked_read (regcache
, IA64_CFM_REGNUM
, buf
);
2464 cfm
= extract_unsigned_integer (buf
, 8, byte_order
);
2466 *val
= ia64_rse_skip_regs (bsp
, -sof
);
2469 case UNW_IA64_AR_BSPSTORE
:
2470 /* Libunwind wants bspstore to be after the current register frame.
2471 This is what ptrace() and gdb treats as the regular bsp value. */
2472 regcache_cooked_read (regcache
, IA64_BSP_REGNUM
, buf
);
2473 *val
= extract_unsigned_integer (buf
, 8, byte_order
);
2477 /* For all other registers, just unwind the value directly. */
2478 regcache_cooked_read (regcache
, regnum
, buf
);
2479 *val
= extract_unsigned_integer (buf
, 8, byte_order
);
2483 if (gdbarch_debug
>= 1)
2484 fprintf_unfiltered (gdb_stdlog
,
2485 " access_rse_reg: from cache: %4s=%s\n",
2486 (((unsigned) regnum
<= IA64_NAT127_REGNUM
)
2487 ? ia64_register_names
[regnum
] : "r??"),
2488 paddress (gdbarch
, *val
));
2493 /* Libunwind callback accessor function for top-level fp registers. */
2495 ia64_access_rse_fpreg (unw_addr_space_t as
, unw_regnum_t uw_regnum
,
2496 unw_fpreg_t
*val
, int write
, void *arg
)
2498 int regnum
= ia64_uw2gdb_regnum (uw_regnum
);
2499 struct regcache
*regcache
= arg
;
2501 /* We never call any libunwind routines that need to write registers. */
2502 gdb_assert (!write
);
2504 regcache_cooked_read (regcache
, regnum
, (char *) val
);
2509 /* Libunwind callback accessor function for accessing memory. */
2511 ia64_access_mem (unw_addr_space_t as
,
2512 unw_word_t addr
, unw_word_t
*val
,
2513 int write
, void *arg
)
2515 if (addr
- KERNEL_START
< ktab_size
)
2517 unw_word_t
*laddr
= (unw_word_t
*) ((char *) ktab
2518 + (addr
- KERNEL_START
));
2527 /* XXX do we need to normalize byte-order here? */
2529 return target_write_memory (addr
, (char *) val
, sizeof (unw_word_t
));
2531 return target_read_memory (addr
, (char *) val
, sizeof (unw_word_t
));
2534 /* Call low-level function to access the kernel unwind table. */
2536 getunwind_table (gdb_byte
**buf_p
)
2540 /* FIXME drow/2005-09-10: This code used to call
2541 ia64_linux_xfer_unwind_table directly to fetch the unwind table
2542 for the currently running ia64-linux kernel. That data should
2543 come from the core file and be accessed via the auxv vector; if
2544 we want to preserve fall back to the running kernel's table, then
2545 we should find a way to override the corefile layer's
2546 xfer_partial method. */
2548 x
= target_read_alloc (¤t_target
, TARGET_OBJECT_UNWIND_TABLE
,
2554 /* Get the kernel unwind table. */
2556 get_kernel_table (unw_word_t ip
, unw_dyn_info_t
*di
)
2558 static struct ia64_table_entry
*etab
;
2565 size
= getunwind_table (&ktab_buf
);
2567 return -UNW_ENOINFO
;
2569 ktab
= (struct ia64_table_entry
*) ktab_buf
;
2572 for (etab
= ktab
; etab
->start_offset
; ++etab
)
2573 etab
->info_offset
+= KERNEL_START
;
2576 if (ip
< ktab
[0].start_offset
|| ip
>= etab
[-1].end_offset
)
2577 return -UNW_ENOINFO
;
2579 di
->format
= UNW_INFO_FORMAT_TABLE
;
2581 di
->start_ip
= ktab
[0].start_offset
;
2582 di
->end_ip
= etab
[-1].end_offset
;
2583 di
->u
.ti
.name_ptr
= (unw_word_t
) "<kernel>";
2584 di
->u
.ti
.segbase
= 0;
2585 di
->u
.ti
.table_len
= ((char *) etab
- (char *) ktab
) / sizeof (unw_word_t
);
2586 di
->u
.ti
.table_data
= (unw_word_t
*) ktab
;
2588 if (gdbarch_debug
>= 1)
2589 fprintf_unfiltered (gdb_stdlog
, "get_kernel_table: found table `%s': "
2590 "segbase=%s, length=%s, gp=%s\n",
2591 (char *) di
->u
.ti
.name_ptr
,
2592 hex_string (di
->u
.ti
.segbase
),
2593 pulongest (di
->u
.ti
.table_len
),
2594 hex_string (di
->gp
));
2598 /* Find the unwind table entry for a specified address. */
2600 ia64_find_unwind_table (struct objfile
*objfile
, unw_word_t ip
,
2601 unw_dyn_info_t
*dip
, void **buf
)
2603 Elf_Internal_Phdr
*phdr
, *p_text
= NULL
, *p_unwind
= NULL
;
2604 Elf_Internal_Ehdr
*ehdr
;
2605 unw_word_t segbase
= 0;
2606 CORE_ADDR load_base
;
2610 bfd
= objfile
->obfd
;
2612 ehdr
= elf_tdata (bfd
)->elf_header
;
2613 phdr
= elf_tdata (bfd
)->phdr
;
2615 load_base
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2617 for (i
= 0; i
< ehdr
->e_phnum
; ++i
)
2619 switch (phdr
[i
].p_type
)
2622 if ((unw_word_t
) (ip
- load_base
- phdr
[i
].p_vaddr
)
2627 case PT_IA_64_UNWIND
:
2628 p_unwind
= phdr
+ i
;
2636 if (!p_text
|| !p_unwind
)
2637 return -UNW_ENOINFO
;
2639 /* Verify that the segment that contains the IP also contains
2640 the static unwind table. If not, we may be in the Linux kernel's
2641 DSO gate page in which case the unwind table is another segment.
2642 Otherwise, we are dealing with runtime-generated code, for which we
2643 have no info here. */
2644 segbase
= p_text
->p_vaddr
+ load_base
;
2646 if ((p_unwind
->p_vaddr
- p_text
->p_vaddr
) >= p_text
->p_memsz
)
2649 for (i
= 0; i
< ehdr
->e_phnum
; ++i
)
2651 if (phdr
[i
].p_type
== PT_LOAD
2652 && (p_unwind
->p_vaddr
- phdr
[i
].p_vaddr
) < phdr
[i
].p_memsz
)
2655 /* Get the segbase from the section containing the
2657 segbase
= phdr
[i
].p_vaddr
+ load_base
;
2661 return -UNW_ENOINFO
;
2664 dip
->start_ip
= p_text
->p_vaddr
+ load_base
;
2665 dip
->end_ip
= dip
->start_ip
+ p_text
->p_memsz
;
2666 dip
->gp
= ia64_find_global_pointer (get_objfile_arch (objfile
), ip
);
2667 dip
->format
= UNW_INFO_FORMAT_REMOTE_TABLE
;
2668 dip
->u
.rti
.name_ptr
= (unw_word_t
) bfd_get_filename (bfd
);
2669 dip
->u
.rti
.segbase
= segbase
;
2670 dip
->u
.rti
.table_len
= p_unwind
->p_memsz
/ sizeof (unw_word_t
);
2671 dip
->u
.rti
.table_data
= p_unwind
->p_vaddr
+ load_base
;
2676 /* Libunwind callback accessor function to acquire procedure unwind-info. */
2678 ia64_find_proc_info_x (unw_addr_space_t as
, unw_word_t ip
, unw_proc_info_t
*pi
,
2679 int need_unwind_info
, void *arg
)
2681 struct obj_section
*sec
= find_pc_section (ip
);
2688 /* XXX This only works if the host and the target architecture are
2689 both ia64 and if the have (more or less) the same kernel
2691 if (get_kernel_table (ip
, &di
) < 0)
2692 return -UNW_ENOINFO
;
2694 if (gdbarch_debug
>= 1)
2695 fprintf_unfiltered (gdb_stdlog
, "ia64_find_proc_info_x: %s -> "
2696 "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
2697 "length=%s,data=%s)\n",
2698 hex_string (ip
), (char *)di
.u
.ti
.name_ptr
,
2699 hex_string (di
.u
.ti
.segbase
),
2700 hex_string (di
.start_ip
), hex_string (di
.end_ip
),
2702 pulongest (di
.u
.ti
.table_len
),
2703 hex_string ((CORE_ADDR
)di
.u
.ti
.table_data
));
2707 ret
= ia64_find_unwind_table (sec
->objfile
, ip
, &di
, &buf
);
2711 if (gdbarch_debug
>= 1)
2712 fprintf_unfiltered (gdb_stdlog
, "ia64_find_proc_info_x: %s -> "
2713 "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
2714 "length=%s,data=%s)\n",
2715 hex_string (ip
), (char *)di
.u
.rti
.name_ptr
,
2716 hex_string (di
.u
.rti
.segbase
),
2717 hex_string (di
.start_ip
), hex_string (di
.end_ip
),
2719 pulongest (di
.u
.rti
.table_len
),
2720 hex_string (di
.u
.rti
.table_data
));
2723 ret
= libunwind_search_unwind_table (&as
, ip
, &di
, pi
, need_unwind_info
,
2726 /* We no longer need the dyn info storage so free it. */
2732 /* Libunwind callback accessor function for cleanup. */
2734 ia64_put_unwind_info (unw_addr_space_t as
,
2735 unw_proc_info_t
*pip
, void *arg
)
2737 /* Nothing required for now. */
2740 /* Libunwind callback accessor function to get head of the dynamic
2741 unwind-info registration list. */
2743 ia64_get_dyn_info_list (unw_addr_space_t as
,
2744 unw_word_t
*dilap
, void *arg
)
2746 struct obj_section
*text_sec
;
2747 struct objfile
*objfile
;
2748 unw_word_t ip
, addr
;
2752 if (!libunwind_is_initialized ())
2753 return -UNW_ENOINFO
;
2755 for (objfile
= object_files
; objfile
; objfile
= objfile
->next
)
2759 text_sec
= objfile
->sections
+ SECT_OFF_TEXT (objfile
);
2760 ip
= obj_section_addr (text_sec
);
2761 ret
= ia64_find_unwind_table (objfile
, ip
, &di
, &buf
);
2764 addr
= libunwind_find_dyn_list (as
, &di
, arg
);
2765 /* We no longer need the dyn info storage so free it. */
2770 if (gdbarch_debug
>= 1)
2771 fprintf_unfiltered (gdb_stdlog
,
2772 "dynamic unwind table in objfile %s "
2774 bfd_get_filename (objfile
->obfd
),
2775 hex_string (addr
), hex_string (di
.gp
));
2781 return -UNW_ENOINFO
;
2785 /* Frame interface functions for libunwind. */
2788 ia64_libunwind_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2789 struct frame_id
*this_id
)
2791 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2792 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2798 libunwind_frame_this_id (this_frame
, this_cache
, &id
);
2799 if (frame_id_eq (id
, null_frame_id
))
2801 (*this_id
) = null_frame_id
;
2805 /* We must add the bsp as the special address for frame comparison
2807 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
2808 bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
2810 (*this_id
) = frame_id_build_special (id
.stack_addr
, id
.code_addr
, bsp
);
2812 if (gdbarch_debug
>= 1)
2813 fprintf_unfiltered (gdb_stdlog
,
2814 "libunwind frame id: code %s, stack %s, special %s, this_frame %s\n",
2815 paddress (gdbarch
, id
.code_addr
),
2816 paddress (gdbarch
, id
.stack_addr
),
2817 paddress (gdbarch
, bsp
),
2818 host_address_to_string (this_frame
));
2821 static struct value
*
2822 ia64_libunwind_frame_prev_register (struct frame_info
*this_frame
,
2823 void **this_cache
, int regnum
)
2826 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2827 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2830 if (VP0_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
2831 reg
= IA64_PR_REGNUM
;
2832 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
2833 reg
= IA64_UNAT_REGNUM
;
2835 /* Let libunwind do most of the work. */
2836 val
= libunwind_frame_prev_register (this_frame
, this_cache
, reg
);
2838 if (VP0_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
2842 if (VP16_REGNUM
<= regnum
&& regnum
<= VP63_REGNUM
)
2846 unsigned char buf
[MAX_REGISTER_SIZE
];
2848 /* Fetch predicate register rename base from current frame
2849 marker for this frame. */
2850 get_frame_register (this_frame
, IA64_CFM_REGNUM
, buf
);
2851 cfm
= extract_unsigned_integer (buf
, 8, byte_order
);
2852 rrb_pr
= (cfm
>> 32) & 0x3f;
2854 /* Adjust the register number to account for register rotation. */
2855 regnum
= VP16_REGNUM
+ ((regnum
- VP16_REGNUM
) + rrb_pr
) % 48;
2857 prN_val
= extract_bit_field (value_contents_all (val
),
2858 regnum
- VP0_REGNUM
, 1);
2859 return frame_unwind_got_constant (this_frame
, regnum
, prN_val
);
2862 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
2866 unatN_val
= extract_bit_field (value_contents_all (val
),
2867 regnum
- IA64_NAT0_REGNUM
, 1);
2868 return frame_unwind_got_constant (this_frame
, regnum
, unatN_val
);
2871 else if (regnum
== IA64_BSP_REGNUM
)
2873 struct value
*cfm_val
;
2874 CORE_ADDR prev_bsp
, prev_cfm
;
2876 /* We want to calculate the previous bsp as the end of the previous
2877 register stack frame. This corresponds to what the hardware bsp
2878 register will be if we pop the frame back which is why we might
2879 have been called. We know that libunwind will pass us back the
2880 beginning of the current frame so we should just add sof to it. */
2881 prev_bsp
= extract_unsigned_integer (value_contents_all (val
),
2883 cfm_val
= libunwind_frame_prev_register (this_frame
, this_cache
,
2885 prev_cfm
= extract_unsigned_integer (value_contents_all (cfm_val
),
2887 prev_bsp
= rse_address_add (prev_bsp
, (prev_cfm
& 0x7f));
2889 return frame_unwind_got_constant (this_frame
, regnum
, prev_bsp
);
2896 ia64_libunwind_frame_sniffer (const struct frame_unwind
*self
,
2897 struct frame_info
*this_frame
,
2900 if (libunwind_is_initialized ()
2901 && libunwind_frame_sniffer (self
, this_frame
, this_cache
))
2907 static const struct frame_unwind ia64_libunwind_frame_unwind
=
2910 ia64_libunwind_frame_this_id
,
2911 ia64_libunwind_frame_prev_register
,
2913 ia64_libunwind_frame_sniffer
,
2914 libunwind_frame_dealloc_cache
2918 ia64_libunwind_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2920 struct frame_id
*this_id
)
2922 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2923 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2929 libunwind_frame_this_id (this_frame
, this_cache
, &id
);
2930 if (frame_id_eq (id
, null_frame_id
))
2932 (*this_id
) = null_frame_id
;
2936 /* We must add the bsp as the special address for frame comparison
2938 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
2939 bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
2941 /* For a sigtramp frame, we don't make the check for previous ip being 0. */
2942 (*this_id
) = frame_id_build_special (id
.stack_addr
, id
.code_addr
, bsp
);
2944 if (gdbarch_debug
>= 1)
2945 fprintf_unfiltered (gdb_stdlog
,
2946 "libunwind sigtramp frame id: code %s, stack %s, special %s, this_frame %s\n",
2947 paddress (gdbarch
, id
.code_addr
),
2948 paddress (gdbarch
, id
.stack_addr
),
2949 paddress (gdbarch
, bsp
),
2950 host_address_to_string (this_frame
));
2953 static struct value
*
2954 ia64_libunwind_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2955 void **this_cache
, int regnum
)
2957 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2958 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2959 struct value
*prev_ip_val
;
2962 /* If the previous frame pc value is 0, then we want to use the SIGCONTEXT
2963 method of getting previous registers. */
2964 prev_ip_val
= libunwind_frame_prev_register (this_frame
, this_cache
,
2966 prev_ip
= extract_unsigned_integer (value_contents_all (prev_ip_val
),
2971 void *tmp_cache
= NULL
;
2972 return ia64_sigtramp_frame_prev_register (this_frame
, &tmp_cache
,
2976 return ia64_libunwind_frame_prev_register (this_frame
, this_cache
, regnum
);
2980 ia64_libunwind_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2981 struct frame_info
*this_frame
,
2984 if (libunwind_is_initialized ())
2986 if (libunwind_sigtramp_frame_sniffer (self
, this_frame
, this_cache
))
2991 return ia64_sigtramp_frame_sniffer (self
, this_frame
, this_cache
);
2994 static const struct frame_unwind ia64_libunwind_sigtramp_frame_unwind
=
2997 ia64_libunwind_sigtramp_frame_this_id
,
2998 ia64_libunwind_sigtramp_frame_prev_register
,
3000 ia64_libunwind_sigtramp_frame_sniffer
3003 /* Set of libunwind callback acccessor functions. */
3004 static unw_accessors_t ia64_unw_accessors
=
3006 ia64_find_proc_info_x
,
3007 ia64_put_unwind_info
,
3008 ia64_get_dyn_info_list
,
3016 /* Set of special libunwind callback acccessor functions specific for accessing
3017 the rse registers. At the top of the stack, we want libunwind to figure out
3018 how to read r32 - r127. Though usually they are found sequentially in memory
3019 starting from $bof, this is not always true. */
3020 static unw_accessors_t ia64_unw_rse_accessors
=
3022 ia64_find_proc_info_x
,
3023 ia64_put_unwind_info
,
3024 ia64_get_dyn_info_list
,
3026 ia64_access_rse_reg
,
3027 ia64_access_rse_fpreg
,
3032 /* Set of ia64 gdb libunwind-frame callbacks and data for generic libunwind-frame code to use. */
3033 static struct libunwind_descr ia64_libunwind_descr
=
3038 &ia64_unw_accessors
,
3039 &ia64_unw_rse_accessors
,
3042 #endif /* HAVE_LIBUNWIND_IA64_H */
3045 ia64_use_struct_convention (struct type
*type
)
3047 struct type
*float_elt_type
;
3049 /* Don't use the struct convention for anything but structure,
3050 union, or array types. */
3051 if (!(TYPE_CODE (type
) == TYPE_CODE_STRUCT
3052 || TYPE_CODE (type
) == TYPE_CODE_UNION
3053 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
))
3056 /* HFAs are structures (or arrays) consisting entirely of floating
3057 point values of the same length. Up to 8 of these are returned
3058 in registers. Don't use the struct convention when this is the
3060 float_elt_type
= is_float_or_hfa_type (type
);
3061 if (float_elt_type
!= NULL
3062 && TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
) <= 8)
3065 /* Other structs of length 32 or less are returned in r8-r11.
3066 Don't use the struct convention for those either. */
3067 return TYPE_LENGTH (type
) > 32;
3071 ia64_extract_return_value (struct type
*type
, struct regcache
*regcache
,
3074 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3075 struct type
*float_elt_type
;
3077 float_elt_type
= is_float_or_hfa_type (type
);
3078 if (float_elt_type
!= NULL
)
3080 char from
[MAX_REGISTER_SIZE
];
3082 int regnum
= IA64_FR8_REGNUM
;
3083 int n
= TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
);
3087 regcache_cooked_read (regcache
, regnum
, from
);
3088 convert_typed_floating (from
, ia64_ext_type (gdbarch
),
3089 (char *)valbuf
+ offset
, float_elt_type
);
3090 offset
+= TYPE_LENGTH (float_elt_type
);
3098 int regnum
= IA64_GR8_REGNUM
;
3099 int reglen
= TYPE_LENGTH (register_type (gdbarch
, IA64_GR8_REGNUM
));
3100 int n
= TYPE_LENGTH (type
) / reglen
;
3101 int m
= TYPE_LENGTH (type
) % reglen
;
3106 regcache_cooked_read_unsigned (regcache
, regnum
, &val
);
3107 memcpy ((char *)valbuf
+ offset
, &val
, reglen
);
3114 regcache_cooked_read_unsigned (regcache
, regnum
, &val
);
3115 memcpy ((char *)valbuf
+ offset
, &val
, m
);
3121 ia64_store_return_value (struct type
*type
, struct regcache
*regcache
,
3122 const gdb_byte
*valbuf
)
3124 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3125 struct type
*float_elt_type
;
3127 float_elt_type
= is_float_or_hfa_type (type
);
3128 if (float_elt_type
!= NULL
)
3130 char to
[MAX_REGISTER_SIZE
];
3132 int regnum
= IA64_FR8_REGNUM
;
3133 int n
= TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
);
3137 convert_typed_floating ((char *)valbuf
+ offset
, float_elt_type
,
3138 to
, ia64_ext_type (gdbarch
));
3139 regcache_cooked_write (regcache
, regnum
, to
);
3140 offset
+= TYPE_LENGTH (float_elt_type
);
3148 int regnum
= IA64_GR8_REGNUM
;
3149 int reglen
= TYPE_LENGTH (register_type (gdbarch
, IA64_GR8_REGNUM
));
3150 int n
= TYPE_LENGTH (type
) / reglen
;
3151 int m
= TYPE_LENGTH (type
) % reglen
;
3156 memcpy (&val
, (char *)valbuf
+ offset
, reglen
);
3157 regcache_cooked_write_unsigned (regcache
, regnum
, val
);
3164 memcpy (&val
, (char *)valbuf
+ offset
, m
);
3165 regcache_cooked_write_unsigned (regcache
, regnum
, val
);
3170 static enum return_value_convention
3171 ia64_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
3172 struct type
*valtype
, struct regcache
*regcache
,
3173 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
3175 int struct_return
= ia64_use_struct_convention (valtype
);
3177 if (writebuf
!= NULL
)
3179 gdb_assert (!struct_return
);
3180 ia64_store_return_value (valtype
, regcache
, writebuf
);
3183 if (readbuf
!= NULL
)
3185 gdb_assert (!struct_return
);
3186 ia64_extract_return_value (valtype
, regcache
, readbuf
);
3190 return RETURN_VALUE_STRUCT_CONVENTION
;
3192 return RETURN_VALUE_REGISTER_CONVENTION
;
3196 is_float_or_hfa_type_recurse (struct type
*t
, struct type
**etp
)
3198 switch (TYPE_CODE (t
))
3202 return TYPE_LENGTH (*etp
) == TYPE_LENGTH (t
);
3209 case TYPE_CODE_ARRAY
:
3211 is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t
)),
3214 case TYPE_CODE_STRUCT
:
3218 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
3219 if (!is_float_or_hfa_type_recurse
3220 (check_typedef (TYPE_FIELD_TYPE (t
, i
)), etp
))
3231 /* Determine if the given type is one of the floating point types or
3232 and HFA (which is a struct, array, or combination thereof whose
3233 bottom-most elements are all of the same floating point type). */
3235 static struct type
*
3236 is_float_or_hfa_type (struct type
*t
)
3238 struct type
*et
= 0;
3240 return is_float_or_hfa_type_recurse (t
, &et
) ? et
: 0;
3244 /* Return 1 if the alignment of T is such that the next even slot
3245 should be used. Return 0, if the next available slot should
3246 be used. (See section 8.5.1 of the IA-64 Software Conventions
3247 and Runtime manual). */
3250 slot_alignment_is_next_even (struct type
*t
)
3252 switch (TYPE_CODE (t
))
3256 if (TYPE_LENGTH (t
) > 8)
3260 case TYPE_CODE_ARRAY
:
3262 slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t
)));
3263 case TYPE_CODE_STRUCT
:
3267 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
3268 if (slot_alignment_is_next_even
3269 (check_typedef (TYPE_FIELD_TYPE (t
, i
))))
3278 /* Attempt to find (and return) the global pointer for the given
3281 This is a rather nasty bit of code searchs for the .dynamic section
3282 in the objfile corresponding to the pc of the function we're trying
3283 to call. Once it finds the addresses at which the .dynamic section
3284 lives in the child process, it scans the Elf64_Dyn entries for a
3285 DT_PLTGOT tag. If it finds one of these, the corresponding
3286 d_un.d_ptr value is the global pointer. */
3289 ia64_find_global_pointer (struct gdbarch
*gdbarch
, CORE_ADDR faddr
)
3291 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3292 struct obj_section
*faddr_sect
;
3294 faddr_sect
= find_pc_section (faddr
);
3295 if (faddr_sect
!= NULL
)
3297 struct obj_section
*osect
;
3299 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
3301 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
3305 if (osect
< faddr_sect
->objfile
->sections_end
)
3307 CORE_ADDR addr
, endaddr
;
3309 addr
= obj_section_addr (osect
);
3310 endaddr
= obj_section_endaddr (osect
);
3312 while (addr
< endaddr
)
3318 status
= target_read_memory (addr
, buf
, sizeof (buf
));
3321 tag
= extract_signed_integer (buf
, sizeof (buf
), byte_order
);
3323 if (tag
== DT_PLTGOT
)
3325 CORE_ADDR global_pointer
;
3327 status
= target_read_memory (addr
+ 8, buf
, sizeof (buf
));
3330 global_pointer
= extract_unsigned_integer (buf
, sizeof (buf
),
3334 return global_pointer
;
3347 /* Given a function's address, attempt to find (and return) the
3348 corresponding (canonical) function descriptor. Return 0 if
3351 find_extant_func_descr (struct gdbarch
*gdbarch
, CORE_ADDR faddr
)
3353 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3354 struct obj_section
*faddr_sect
;
3356 /* Return early if faddr is already a function descriptor. */
3357 faddr_sect
= find_pc_section (faddr
);
3358 if (faddr_sect
&& strcmp (faddr_sect
->the_bfd_section
->name
, ".opd") == 0)
3361 if (faddr_sect
!= NULL
)
3363 struct obj_section
*osect
;
3364 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
3366 if (strcmp (osect
->the_bfd_section
->name
, ".opd") == 0)
3370 if (osect
< faddr_sect
->objfile
->sections_end
)
3372 CORE_ADDR addr
, endaddr
;
3374 addr
= obj_section_addr (osect
);
3375 endaddr
= obj_section_endaddr (osect
);
3377 while (addr
< endaddr
)
3383 status
= target_read_memory (addr
, buf
, sizeof (buf
));
3386 faddr2
= extract_signed_integer (buf
, sizeof (buf
), byte_order
);
3388 if (faddr
== faddr2
)
3398 /* Attempt to find a function descriptor corresponding to the
3399 given address. If none is found, construct one on the
3400 stack using the address at fdaptr. */
3403 find_func_descr (struct regcache
*regcache
, CORE_ADDR faddr
, CORE_ADDR
*fdaptr
)
3405 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3406 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3409 fdesc
= find_extant_func_descr (gdbarch
, faddr
);
3413 ULONGEST global_pointer
;
3419 global_pointer
= ia64_find_global_pointer (gdbarch
, faddr
);
3421 if (global_pointer
== 0)
3422 regcache_cooked_read_unsigned (regcache
,
3423 IA64_GR1_REGNUM
, &global_pointer
);
3425 store_unsigned_integer (buf
, 8, byte_order
, faddr
);
3426 store_unsigned_integer (buf
+ 8, 8, byte_order
, global_pointer
);
3428 write_memory (fdesc
, buf
, 16);
3434 /* Use the following routine when printing out function pointers
3435 so the user can see the function address rather than just the
3436 function descriptor. */
3438 ia64_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
3439 struct target_ops
*targ
)
3441 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3442 struct obj_section
*s
;
3444 s
= find_pc_section (addr
);
3446 /* check if ADDR points to a function descriptor. */
3447 if (s
&& strcmp (s
->the_bfd_section
->name
, ".opd") == 0)
3448 return read_memory_unsigned_integer (addr
, 8, byte_order
);
3450 /* Normally, functions live inside a section that is executable.
3451 So, if ADDR points to a non-executable section, then treat it
3452 as a function descriptor and return the target address iff
3453 the target address itself points to a section that is executable. */
3454 if (s
&& (s
->the_bfd_section
->flags
& SEC_CODE
) == 0)
3456 CORE_ADDR pc
= read_memory_unsigned_integer (addr
, 8, byte_order
);
3457 struct obj_section
*pc_section
= find_pc_section (pc
);
3459 if (pc_section
&& (pc_section
->the_bfd_section
->flags
& SEC_CODE
))
3463 /* There are also descriptors embedded in vtables. */
3466 struct minimal_symbol
*minsym
;
3468 minsym
= lookup_minimal_symbol_by_pc (addr
);
3470 if (minsym
&& is_vtable_name (SYMBOL_LINKAGE_NAME (minsym
)))
3471 return read_memory_unsigned_integer (addr
, 8, byte_order
);
3478 ia64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
3484 ia64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
3485 struct regcache
*regcache
, CORE_ADDR bp_addr
,
3486 int nargs
, struct value
**args
, CORE_ADDR sp
,
3487 int struct_return
, CORE_ADDR struct_addr
)
3489 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3494 int nslots
, rseslots
, memslots
, slotnum
, nfuncargs
;
3496 ULONGEST bsp
, cfm
, pfs
, new_bsp
;
3497 CORE_ADDR funcdescaddr
, pc
, global_pointer
;
3498 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
3502 /* Count the number of slots needed for the arguments. */
3503 for (argno
= 0; argno
< nargs
; argno
++)
3506 type
= check_typedef (value_type (arg
));
3507 len
= TYPE_LENGTH (type
);
3509 if ((nslots
& 1) && slot_alignment_is_next_even (type
))
3512 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
3515 nslots
+= (len
+ 7) / 8;
3518 /* Divvy up the slots between the RSE and the memory stack. */
3519 rseslots
= (nslots
> 8) ? 8 : nslots
;
3520 memslots
= nslots
- rseslots
;
3522 /* Allocate a new RSE frame. */
3523 regcache_cooked_read_unsigned (regcache
, IA64_CFM_REGNUM
, &cfm
);
3525 regcache_cooked_read_unsigned (regcache
, IA64_BSP_REGNUM
, &bsp
);
3526 new_bsp
= rse_address_add (bsp
, rseslots
);
3527 regcache_cooked_write_unsigned (regcache
, IA64_BSP_REGNUM
, new_bsp
);
3529 regcache_cooked_read_unsigned (regcache
, IA64_PFS_REGNUM
, &pfs
);
3530 pfs
&= 0xc000000000000000LL
;
3531 pfs
|= (cfm
& 0xffffffffffffLL
);
3532 regcache_cooked_write_unsigned (regcache
, IA64_PFS_REGNUM
, pfs
);
3534 cfm
&= 0xc000000000000000LL
;
3536 regcache_cooked_write_unsigned (regcache
, IA64_CFM_REGNUM
, cfm
);
3538 /* We will attempt to find function descriptors in the .opd segment,
3539 but if we can't we'll construct them ourselves. That being the
3540 case, we'll need to reserve space on the stack for them. */
3541 funcdescaddr
= sp
- nfuncargs
* 16;
3542 funcdescaddr
&= ~0xfLL
;
3544 /* Adjust the stack pointer to it's new value. The calling conventions
3545 require us to have 16 bytes of scratch, plus whatever space is
3546 necessary for the memory slots and our function descriptors. */
3547 sp
= sp
- 16 - (memslots
+ nfuncargs
) * 8;
3548 sp
&= ~0xfLL
; /* Maintain 16 byte alignment. */
3550 /* Place the arguments where they belong. The arguments will be
3551 either placed in the RSE backing store or on the memory stack.
3552 In addition, floating point arguments or HFAs are placed in
3553 floating point registers. */
3555 floatreg
= IA64_FR8_REGNUM
;
3556 for (argno
= 0; argno
< nargs
; argno
++)
3558 struct type
*float_elt_type
;
3561 type
= check_typedef (value_type (arg
));
3562 len
= TYPE_LENGTH (type
);
3564 /* Special handling for function parameters. */
3566 && TYPE_CODE (type
) == TYPE_CODE_PTR
3567 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
3570 ULONGEST faddr
= extract_unsigned_integer (value_contents (arg
),
3572 store_unsigned_integer (val_buf
, 8, byte_order
,
3573 find_func_descr (regcache
, faddr
,
3575 if (slotnum
< rseslots
)
3576 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
3578 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
3585 /* Skip odd slot if necessary... */
3586 if ((slotnum
& 1) && slot_alignment_is_next_even (type
))
3594 memset (val_buf
, 0, 8);
3595 memcpy (val_buf
, value_contents (arg
) + argoffset
, (len
> 8) ? 8 : len
);
3597 if (slotnum
< rseslots
)
3598 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
3600 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
3607 /* Handle floating point types (including HFAs). */
3608 float_elt_type
= is_float_or_hfa_type (type
);
3609 if (float_elt_type
!= NULL
)
3612 len
= TYPE_LENGTH (type
);
3613 while (len
> 0 && floatreg
< IA64_FR16_REGNUM
)
3615 char to
[MAX_REGISTER_SIZE
];
3616 convert_typed_floating (value_contents (arg
) + argoffset
, float_elt_type
,
3617 to
, ia64_ext_type (gdbarch
));
3618 regcache_cooked_write (regcache
, floatreg
, (void *)to
);
3620 argoffset
+= TYPE_LENGTH (float_elt_type
);
3621 len
-= TYPE_LENGTH (float_elt_type
);
3626 /* Store the struct return value in r8 if necessary. */
3629 regcache_cooked_write_unsigned (regcache
, IA64_GR8_REGNUM
, (ULONGEST
)struct_addr
);
3632 global_pointer
= ia64_find_global_pointer (gdbarch
, func_addr
);
3634 if (global_pointer
!= 0)
3635 regcache_cooked_write_unsigned (regcache
, IA64_GR1_REGNUM
, global_pointer
);
3637 regcache_cooked_write_unsigned (regcache
, IA64_BR0_REGNUM
, bp_addr
);
3639 regcache_cooked_write_unsigned (regcache
, sp_regnum
, sp
);
3644 static struct frame_id
3645 ia64_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
3647 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3651 get_frame_register (this_frame
, sp_regnum
, buf
);
3652 sp
= extract_unsigned_integer (buf
, 8, byte_order
);
3654 get_frame_register (this_frame
, IA64_BSP_REGNUM
, buf
);
3655 bsp
= extract_unsigned_integer (buf
, 8, byte_order
);
3657 if (gdbarch_debug
>= 1)
3658 fprintf_unfiltered (gdb_stdlog
,
3659 "dummy frame id: code %s, stack %s, special %s\n",
3660 paddress (gdbarch
, get_frame_pc (this_frame
)),
3661 paddress (gdbarch
, sp
), paddress (gdbarch
, bsp
));
3663 return frame_id_build_special (sp
, get_frame_pc (this_frame
), bsp
);
3667 ia64_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
3669 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3671 CORE_ADDR ip
, psr
, pc
;
3673 frame_unwind_register (next_frame
, IA64_IP_REGNUM
, buf
);
3674 ip
= extract_unsigned_integer (buf
, 8, byte_order
);
3675 frame_unwind_register (next_frame
, IA64_PSR_REGNUM
, buf
);
3676 psr
= extract_unsigned_integer (buf
, 8, byte_order
);
3678 pc
= (ip
& ~0xf) | ((psr
>> 41) & 3);
3683 ia64_print_insn (bfd_vma memaddr
, struct disassemble_info
*info
)
3685 info
->bytes_per_line
= SLOT_MULTIPLIER
;
3686 return print_insn_ia64 (memaddr
, info
);
3689 static struct gdbarch
*
3690 ia64_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3692 struct gdbarch
*gdbarch
;
3693 struct gdbarch_tdep
*tdep
;
3695 /* If there is already a candidate, use it. */
3696 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3698 return arches
->gdbarch
;
3700 tdep
= xzalloc (sizeof (struct gdbarch_tdep
));
3701 gdbarch
= gdbarch_alloc (&info
, tdep
);
3703 /* According to the ia64 specs, instructions that store long double
3704 floats in memory use a long-double format different than that
3705 used in the floating registers. The memory format matches the
3706 x86 extended float format which is 80 bits. An OS may choose to
3707 use this format (e.g. GNU/Linux) or choose to use a different
3708 format for storing long doubles (e.g. HPUX). In the latter case,
3709 the setting of the format may be moved/overridden in an
3710 OS-specific tdep file. */
3711 set_gdbarch_long_double_format (gdbarch
, floatformats_i387_ext
);
3713 set_gdbarch_short_bit (gdbarch
, 16);
3714 set_gdbarch_int_bit (gdbarch
, 32);
3715 set_gdbarch_long_bit (gdbarch
, 64);
3716 set_gdbarch_long_long_bit (gdbarch
, 64);
3717 set_gdbarch_float_bit (gdbarch
, 32);
3718 set_gdbarch_double_bit (gdbarch
, 64);
3719 set_gdbarch_long_double_bit (gdbarch
, 128);
3720 set_gdbarch_ptr_bit (gdbarch
, 64);
3722 set_gdbarch_num_regs (gdbarch
, NUM_IA64_RAW_REGS
);
3723 set_gdbarch_num_pseudo_regs (gdbarch
, LAST_PSEUDO_REGNUM
- FIRST_PSEUDO_REGNUM
);
3724 set_gdbarch_sp_regnum (gdbarch
, sp_regnum
);
3725 set_gdbarch_fp0_regnum (gdbarch
, IA64_FR0_REGNUM
);
3727 set_gdbarch_register_name (gdbarch
, ia64_register_name
);
3728 set_gdbarch_register_type (gdbarch
, ia64_register_type
);
3730 set_gdbarch_pseudo_register_read (gdbarch
, ia64_pseudo_register_read
);
3731 set_gdbarch_pseudo_register_write (gdbarch
, ia64_pseudo_register_write
);
3732 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, ia64_dwarf_reg_to_regnum
);
3733 set_gdbarch_register_reggroup_p (gdbarch
, ia64_register_reggroup_p
);
3734 set_gdbarch_convert_register_p (gdbarch
, ia64_convert_register_p
);
3735 set_gdbarch_register_to_value (gdbarch
, ia64_register_to_value
);
3736 set_gdbarch_value_to_register (gdbarch
, ia64_value_to_register
);
3738 set_gdbarch_skip_prologue (gdbarch
, ia64_skip_prologue
);
3740 set_gdbarch_return_value (gdbarch
, ia64_return_value
);
3742 set_gdbarch_memory_insert_breakpoint (gdbarch
, ia64_memory_insert_breakpoint
);
3743 set_gdbarch_memory_remove_breakpoint (gdbarch
, ia64_memory_remove_breakpoint
);
3744 set_gdbarch_breakpoint_from_pc (gdbarch
, ia64_breakpoint_from_pc
);
3745 set_gdbarch_read_pc (gdbarch
, ia64_read_pc
);
3746 set_gdbarch_write_pc (gdbarch
, ia64_write_pc
);
3748 /* Settings for calling functions in the inferior. */
3749 set_gdbarch_push_dummy_call (gdbarch
, ia64_push_dummy_call
);
3750 set_gdbarch_frame_align (gdbarch
, ia64_frame_align
);
3751 set_gdbarch_dummy_id (gdbarch
, ia64_dummy_id
);
3753 set_gdbarch_unwind_pc (gdbarch
, ia64_unwind_pc
);
3754 #ifdef HAVE_LIBUNWIND_IA64_H
3755 frame_unwind_append_unwinder (gdbarch
,
3756 &ia64_libunwind_sigtramp_frame_unwind
);
3757 frame_unwind_append_unwinder (gdbarch
, &ia64_libunwind_frame_unwind
);
3758 frame_unwind_append_unwinder (gdbarch
, &ia64_sigtramp_frame_unwind
);
3759 libunwind_frame_set_descr (gdbarch
, &ia64_libunwind_descr
);
3761 frame_unwind_append_unwinder (gdbarch
, &ia64_sigtramp_frame_unwind
);
3763 frame_unwind_append_unwinder (gdbarch
, &ia64_frame_unwind
);
3764 frame_base_set_default (gdbarch
, &ia64_frame_base
);
3766 /* Settings that should be unnecessary. */
3767 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3769 set_gdbarch_print_insn (gdbarch
, ia64_print_insn
);
3770 set_gdbarch_convert_from_func_ptr_addr (gdbarch
, ia64_convert_from_func_ptr_addr
);
3772 /* The virtual table contains 16-byte descriptors, not pointers to
3774 set_gdbarch_vtable_function_descriptors (gdbarch
, 1);
3776 /* Hook in ABI-specific overrides, if they have been registered. */
3777 gdbarch_init_osabi (info
, gdbarch
);
3782 extern initialize_file_ftype _initialize_ia64_tdep
; /* -Wmissing-prototypes */
3785 _initialize_ia64_tdep (void)
3787 gdbarch_register (bfd_arch_ia64
, ia64_gdbarch_init
, NULL
);