1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
3 Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "symfile.h" /* for entry_point_address */
26 #include "arch-utils.h"
27 #include "floatformat.h"
33 #include "elf/common.h" /* for DT_PLTGOT value */
36 /* Hook for determining the global pointer when calling functions in
37 the inferior under AIX. The initialization code in ia64-aix-nat.c
38 sets this hook to the address of a function which will find the
39 global pointer for a given address.
41 The generic code which uses the dynamic section in the inferior for
42 finding the global pointer is not of much use on AIX since the
43 values obtained from the inferior have not been relocated. */
45 CORE_ADDR (*native_find_global_pointer
) (CORE_ADDR
) = 0;
47 /* An enumeration of the different IA-64 instruction types. */
49 typedef enum instruction_type
51 A
, /* Integer ALU ; I-unit or M-unit */
52 I
, /* Non-ALU integer; I-unit */
53 M
, /* Memory ; M-unit */
54 F
, /* Floating-point ; F-unit */
55 B
, /* Branch ; B-unit */
56 L
, /* Extended (L+X) ; I-unit */
57 X
, /* Extended (L+X) ; I-unit */
58 undefined
/* undefined or reserved */
61 /* We represent IA-64 PC addresses as the value of the instruction
62 pointer or'd with some bit combination in the low nibble which
63 represents the slot number in the bundle addressed by the
64 instruction pointer. The problem is that the Linux kernel
65 multiplies its slot numbers (for exceptions) by one while the
66 disassembler multiplies its slot numbers by 6. In addition, I've
67 heard it said that the simulator uses 1 as the multiplier.
69 I've fixed the disassembler so that the bytes_per_line field will
70 be the slot multiplier. If bytes_per_line comes in as zero, it
71 is set to six (which is how it was set up initially). -- objdump
72 displays pretty disassembly dumps with this value. For our purposes,
73 we'll set bytes_per_line to SLOT_MULTIPLIER. This is okay since we
74 never want to also display the raw bytes the way objdump does. */
76 #define SLOT_MULTIPLIER 1
78 /* Length in bytes of an instruction bundle */
82 /* FIXME: These extern declarations should go in ia64-tdep.h. */
83 extern CORE_ADDR
ia64_linux_sigcontext_register_address (CORE_ADDR
, int);
84 extern CORE_ADDR
ia64_aix_sigcontext_register_address (CORE_ADDR
, int);
86 static gdbarch_init_ftype ia64_gdbarch_init
;
88 static gdbarch_register_name_ftype ia64_register_name
;
89 static gdbarch_register_raw_size_ftype ia64_register_raw_size
;
90 static gdbarch_register_virtual_size_ftype ia64_register_virtual_size
;
91 static gdbarch_register_virtual_type_ftype ia64_register_virtual_type
;
92 static gdbarch_register_byte_ftype ia64_register_byte
;
93 static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc
;
94 static gdbarch_skip_prologue_ftype ia64_skip_prologue
;
95 static gdbarch_deprecated_extract_return_value_ftype ia64_extract_return_value
;
96 static gdbarch_deprecated_extract_struct_value_address_ftype ia64_extract_struct_value_address
;
97 static gdbarch_use_struct_convention_ftype ia64_use_struct_convention
;
98 static gdbarch_frameless_function_invocation_ftype ia64_frameless_function_invocation
;
99 static gdbarch_store_struct_return_ftype ia64_store_struct_return
;
100 static gdbarch_push_arguments_ftype ia64_push_arguments
;
101 static gdbarch_push_return_address_ftype ia64_push_return_address
;
102 static gdbarch_saved_pc_after_call_ftype ia64_saved_pc_after_call
;
103 static void ia64_pop_frame_regular (struct frame_info
*frame
);
104 static struct type
*is_float_or_hfa_type (struct type
*t
);
106 static int ia64_num_regs
= 590;
108 static int pc_regnum
= IA64_IP_REGNUM
;
109 static int sp_regnum
= IA64_GR12_REGNUM
;
110 static int fp_regnum
= IA64_VFP_REGNUM
;
111 static int lr_regnum
= IA64_VRAP_REGNUM
;
113 static LONGEST ia64_call_dummy_words
[] = {0};
115 /* Array of register names; There should be ia64_num_regs strings in
118 static char *ia64_register_names
[] =
119 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
120 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
121 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
122 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
123 "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
124 "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
125 "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
126 "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
127 "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
128 "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
129 "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
130 "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
131 "r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
132 "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
133 "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
134 "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
136 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
137 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
138 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
139 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
140 "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
141 "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47",
142 "f48", "f49", "f50", "f51", "f52", "f53", "f54", "f55",
143 "f56", "f57", "f58", "f59", "f60", "f61", "f62", "f63",
144 "f64", "f65", "f66", "f67", "f68", "f69", "f70", "f71",
145 "f72", "f73", "f74", "f75", "f76", "f77", "f78", "f79",
146 "f80", "f81", "f82", "f83", "f84", "f85", "f86", "f87",
147 "f88", "f89", "f90", "f91", "f92", "f93", "f94", "f95",
148 "f96", "f97", "f98", "f99", "f100", "f101", "f102", "f103",
149 "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
150 "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
151 "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
153 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
154 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
155 "p16", "p17", "p18", "p19", "p20", "p21", "p22", "p23",
156 "p24", "p25", "p26", "p27", "p28", "p29", "p30", "p31",
157 "p32", "p33", "p34", "p35", "p36", "p37", "p38", "p39",
158 "p40", "p41", "p42", "p43", "p44", "p45", "p46", "p47",
159 "p48", "p49", "p50", "p51", "p52", "p53", "p54", "p55",
160 "p56", "p57", "p58", "p59", "p60", "p61", "p62", "p63",
162 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
166 "pr", "ip", "psr", "cfm",
168 "kr0", "kr1", "kr2", "kr3", "kr4", "kr5", "kr6", "kr7",
169 "", "", "", "", "", "", "", "",
170 "rsc", "bsp", "bspstore", "rnat",
172 "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr", "",
173 "ccv", "", "", "", "unat", "", "", "",
174 "fpsr", "", "", "", "itc",
175 "", "", "", "", "", "", "", "", "", "",
176 "", "", "", "", "", "", "", "", "",
178 "", "", "", "", "", "", "", "", "", "",
179 "", "", "", "", "", "", "", "", "", "",
180 "", "", "", "", "", "", "", "", "", "",
181 "", "", "", "", "", "", "", "", "", "",
182 "", "", "", "", "", "", "", "", "", "",
183 "", "", "", "", "", "", "", "", "", "",
185 "nat0", "nat1", "nat2", "nat3", "nat4", "nat5", "nat6", "nat7",
186 "nat8", "nat9", "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
187 "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
188 "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
189 "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
190 "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
191 "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
192 "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
193 "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
194 "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
195 "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
196 "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
197 "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
198 "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
199 "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
200 "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
203 struct frame_extra_info
205 CORE_ADDR bsp
; /* points at r32 for the current frame */
206 CORE_ADDR cfm
; /* cfm value for current frame */
207 int sof
; /* Size of frame (decoded from cfm value) */
208 int sol
; /* Size of locals (decoded from cfm value) */
209 CORE_ADDR after_prologue
;
210 /* Address of first instruction after the last
211 prologue instruction; Note that there may
212 be instructions from the function's body
213 intermingled with the prologue. */
214 int mem_stack_frame_size
;
215 /* Size of the memory stack frame (may be zero),
216 or -1 if it has not been determined yet. */
217 int fp_reg
; /* Register number (if any) used a frame pointer
218 for this frame. 0 if no register is being used
219 as the frame pointer. */
224 int os_ident
; /* From the ELF header, one of the ELFOSABI_
225 constants: ELFOSABI_LINUX, ELFOSABI_AIX,
227 CORE_ADDR (*sigcontext_register_address
) (CORE_ADDR
, int);
228 /* OS specific function which, given a frame address
229 and register number, returns the offset to the
230 given register from the start of the frame. */
231 CORE_ADDR (*find_global_pointer
) (CORE_ADDR
);
234 #define SIGCONTEXT_REGISTER_ADDRESS \
235 (gdbarch_tdep (current_gdbarch)->sigcontext_register_address)
236 #define FIND_GLOBAL_POINTER \
237 (gdbarch_tdep (current_gdbarch)->find_global_pointer)
240 ia64_register_name (int reg
)
242 return ia64_register_names
[reg
];
246 ia64_register_raw_size (int reg
)
248 return (IA64_FR0_REGNUM
<= reg
&& reg
<= IA64_FR127_REGNUM
) ? 16 : 8;
252 ia64_register_virtual_size (int reg
)
254 return (IA64_FR0_REGNUM
<= reg
&& reg
<= IA64_FR127_REGNUM
) ? 16 : 8;
257 /* Return true iff register N's virtual format is different from
260 ia64_register_convertible (int nr
)
262 return (IA64_FR0_REGNUM
<= nr
&& nr
<= IA64_FR127_REGNUM
);
265 const struct floatformat floatformat_ia64_ext
=
267 floatformat_little
, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
268 floatformat_intbit_yes
272 ia64_register_convert_to_virtual (int regnum
, struct type
*type
,
273 char *from
, char *to
)
275 if (regnum
>= IA64_FR0_REGNUM
&& regnum
<= IA64_FR127_REGNUM
)
278 floatformat_to_doublest (&floatformat_ia64_ext
, from
, &val
);
279 store_floating(to
, TYPE_LENGTH(type
), val
);
282 error("ia64_register_convert_to_virtual called with non floating point register number");
286 ia64_register_convert_to_raw (struct type
*type
, int regnum
,
287 char *from
, char *to
)
289 if (regnum
>= IA64_FR0_REGNUM
&& regnum
<= IA64_FR127_REGNUM
)
291 DOUBLEST val
= extract_floating (from
, TYPE_LENGTH(type
));
292 floatformat_from_doublest (&floatformat_ia64_ext
, &val
, to
);
295 error("ia64_register_convert_to_raw called with non floating point register number");
299 ia64_register_virtual_type (int reg
)
301 if (reg
>= IA64_FR0_REGNUM
&& reg
<= IA64_FR127_REGNUM
)
302 return builtin_type_long_double
;
304 return builtin_type_long
;
308 ia64_register_byte (int reg
)
311 (reg
<= IA64_FR0_REGNUM
? 0 : 8 * ((reg
> IA64_FR127_REGNUM
) ? 128 : reg
- IA64_FR0_REGNUM
));
314 /* Read the given register from a sigcontext structure in the
318 read_sigcontext_register (struct frame_info
*frame
, int regnum
)
323 internal_error (__FILE__
, __LINE__
,
324 "read_sigcontext_register: NULL frame");
325 if (!(get_frame_type (frame
) == SIGTRAMP_FRAME
))
326 internal_error (__FILE__
, __LINE__
,
327 "read_sigcontext_register: frame not a signal trampoline");
328 if (SIGCONTEXT_REGISTER_ADDRESS
== 0)
329 internal_error (__FILE__
, __LINE__
,
330 "read_sigcontext_register: SIGCONTEXT_REGISTER_ADDRESS is 0");
332 regaddr
= SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regnum
);
334 return read_memory_integer (regaddr
, REGISTER_RAW_SIZE (regnum
));
336 internal_error (__FILE__
, __LINE__
,
337 "read_sigcontext_register: Register %d not in struct sigcontext", regnum
);
340 /* Extract ``len'' bits from an instruction bundle starting at
344 extract_bit_field (char *bundle
, int from
, int len
)
346 long long result
= 0LL;
348 int from_byte
= from
/ 8;
349 int to_byte
= to
/ 8;
350 unsigned char *b
= (unsigned char *) bundle
;
356 if (from_byte
== to_byte
)
357 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
358 result
= c
>> (from
% 8);
359 lshift
= 8 - (from
% 8);
361 for (i
= from_byte
+1; i
< to_byte
; i
++)
363 result
|= ((long long) b
[i
]) << lshift
;
367 if (from_byte
< to_byte
&& (to
% 8 != 0))
370 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
371 result
|= ((long long) c
) << lshift
;
377 /* Replace the specified bits in an instruction bundle */
380 replace_bit_field (char *bundle
, long long val
, int from
, int len
)
383 int from_byte
= from
/ 8;
384 int to_byte
= to
/ 8;
385 unsigned char *b
= (unsigned char *) bundle
;
388 if (from_byte
== to_byte
)
390 unsigned char left
, right
;
392 left
= (c
>> (to
% 8)) << (to
% 8);
393 right
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
394 c
= (unsigned char) (val
& 0xff);
395 c
= (unsigned char) (c
<< (from
% 8 + 8 - to
% 8)) >> (8 - to
% 8);
403 c
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
404 c
= c
| (val
<< (from
% 8));
406 val
>>= 8 - from
% 8;
408 for (i
= from_byte
+1; i
< to_byte
; i
++)
417 unsigned char cv
= (unsigned char) val
;
419 c
= c
>> (to
% 8) << (to
% 8);
420 c
|= ((unsigned char) (cv
<< (8 - to
% 8))) >> (8 - to
% 8);
426 /* Return the contents of slot N (for N = 0, 1, or 2) in
427 and instruction bundle */
430 slotN_contents (char *bundle
, int slotnum
)
432 return extract_bit_field (bundle
, 5+41*slotnum
, 41);
435 /* Store an instruction in an instruction bundle */
438 replace_slotN_contents (char *bundle
, long long instr
, int slotnum
)
440 replace_bit_field (bundle
, instr
, 5+41*slotnum
, 41);
443 static enum instruction_type template_encoding_table
[32][3] =
445 { M
, I
, I
}, /* 00 */
446 { M
, I
, I
}, /* 01 */
447 { M
, I
, I
}, /* 02 */
448 { M
, I
, I
}, /* 03 */
449 { M
, L
, X
}, /* 04 */
450 { M
, L
, X
}, /* 05 */
451 { undefined
, undefined
, undefined
}, /* 06 */
452 { undefined
, undefined
, undefined
}, /* 07 */
453 { M
, M
, I
}, /* 08 */
454 { M
, M
, I
}, /* 09 */
455 { M
, M
, I
}, /* 0A */
456 { M
, M
, I
}, /* 0B */
457 { M
, F
, I
}, /* 0C */
458 { M
, F
, I
}, /* 0D */
459 { M
, M
, F
}, /* 0E */
460 { M
, M
, F
}, /* 0F */
461 { M
, I
, B
}, /* 10 */
462 { M
, I
, B
}, /* 11 */
463 { M
, B
, B
}, /* 12 */
464 { M
, B
, B
}, /* 13 */
465 { undefined
, undefined
, undefined
}, /* 14 */
466 { undefined
, undefined
, undefined
}, /* 15 */
467 { B
, B
, B
}, /* 16 */
468 { B
, B
, B
}, /* 17 */
469 { M
, M
, B
}, /* 18 */
470 { M
, M
, B
}, /* 19 */
471 { undefined
, undefined
, undefined
}, /* 1A */
472 { undefined
, undefined
, undefined
}, /* 1B */
473 { M
, F
, B
}, /* 1C */
474 { M
, F
, B
}, /* 1D */
475 { undefined
, undefined
, undefined
}, /* 1E */
476 { undefined
, undefined
, undefined
}, /* 1F */
479 /* Fetch and (partially) decode an instruction at ADDR and return the
480 address of the next instruction to fetch. */
483 fetch_instruction (CORE_ADDR addr
, instruction_type
*it
, long long *instr
)
485 char bundle
[BUNDLE_LEN
];
486 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
490 /* Warn about slot numbers greater than 2. We used to generate
491 an error here on the assumption that the user entered an invalid
492 address. But, sometimes GDB itself requests an invalid address.
493 This can (easily) happen when execution stops in a function for
494 which there are no symbols. The prologue scanner will attempt to
495 find the beginning of the function - if the nearest symbol
496 happens to not be aligned on a bundle boundary (16 bytes), the
497 resulting starting address will cause GDB to think that the slot
500 So we warn about it and set the slot number to zero. It is
501 not necessarily a fatal condition, particularly if debugging
502 at the assembly language level. */
505 warning ("Can't fetch instructions for slot numbers greater than 2.\n"
506 "Using slot 0 instead");
512 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
517 *instr
= slotN_contents (bundle
, slotnum
);
518 template = extract_bit_field (bundle
, 0, 5);
519 *it
= template_encoding_table
[(int)template][slotnum
];
521 if (slotnum
== 2 || (slotnum
== 1 && *it
== L
))
524 addr
+= (slotnum
+ 1) * SLOT_MULTIPLIER
;
529 /* There are 5 different break instructions (break.i, break.b,
530 break.m, break.f, and break.x), but they all have the same
531 encoding. (The five bit template in the low five bits of the
532 instruction bundle distinguishes one from another.)
534 The runtime architecture manual specifies that break instructions
535 used for debugging purposes must have the upper two bits of the 21
536 bit immediate set to a 0 and a 1 respectively. A breakpoint
537 instruction encodes the most significant bit of its 21 bit
538 immediate at bit 36 of the 41 bit instruction. The penultimate msb
539 is at bit 25 which leads to the pattern below.
541 Originally, I had this set up to do, e.g, a "break.i 0x80000" But
542 it turns out that 0x80000 was used as the syscall break in the early
543 simulators. So I changed the pattern slightly to do "break.i 0x080001"
544 instead. But that didn't work either (I later found out that this
545 pattern was used by the simulator that I was using.) So I ended up
546 using the pattern seen below. */
549 #define BREAKPOINT 0x00002000040LL
551 #define BREAKPOINT 0x00003333300LL
554 ia64_memory_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
556 char bundle
[BUNDLE_LEN
];
557 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
563 error("Can't insert breakpoint for slot numbers greater than 2.");
567 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
569 /* Check for L type instruction in 2nd slot, if present then
570 bump up the slot number to the 3rd slot */
571 template = extract_bit_field (bundle
, 0, 5);
572 if (slotnum
== 1 && template_encoding_table
[template][1] == L
)
577 instr
= slotN_contents (bundle
, slotnum
);
578 memcpy(contents_cache
, &instr
, sizeof(instr
));
579 replace_slotN_contents (bundle
, BREAKPOINT
, slotnum
);
581 target_write_memory (addr
, bundle
, BUNDLE_LEN
);
587 ia64_memory_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
589 char bundle
[BUNDLE_LEN
];
590 int slotnum
= (addr
& 0x0f) / SLOT_MULTIPLIER
;
597 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
599 /* Check for L type instruction in 2nd slot, if present then
600 bump up the slot number to the 3rd slot */
601 template = extract_bit_field (bundle
, 0, 5);
602 if (slotnum
== 1 && template_encoding_table
[template][1] == L
)
607 memcpy (&instr
, contents_cache
, sizeof instr
);
608 replace_slotN_contents (bundle
, instr
, slotnum
);
610 target_write_memory (addr
, bundle
, BUNDLE_LEN
);
615 /* We don't really want to use this, but remote.c needs to call it in order
616 to figure out if Z-packets are supported or not. Oh, well. */
617 const unsigned char *
618 ia64_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
620 static unsigned char breakpoint
[] =
621 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
622 *lenptr
= sizeof (breakpoint
);
630 ia64_read_pc (ptid_t ptid
)
632 CORE_ADDR psr_value
= read_register_pid (IA64_PSR_REGNUM
, ptid
);
633 CORE_ADDR pc_value
= read_register_pid (IA64_IP_REGNUM
, ptid
);
634 int slot_num
= (psr_value
>> 41) & 3;
636 return pc_value
| (slot_num
* SLOT_MULTIPLIER
);
640 ia64_write_pc (CORE_ADDR new_pc
, ptid_t ptid
)
642 int slot_num
= (int) (new_pc
& 0xf) / SLOT_MULTIPLIER
;
643 CORE_ADDR psr_value
= read_register_pid (IA64_PSR_REGNUM
, ptid
);
644 psr_value
&= ~(3LL << 41);
645 psr_value
|= (CORE_ADDR
)(slot_num
& 0x3) << 41;
649 write_register_pid (IA64_PSR_REGNUM
, psr_value
, ptid
);
650 write_register_pid (IA64_IP_REGNUM
, new_pc
, ptid
);
653 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
655 /* Returns the address of the slot that's NSLOTS slots away from
656 the address ADDR. NSLOTS may be positive or negative. */
658 rse_address_add(CORE_ADDR addr
, int nslots
)
661 int mandatory_nat_slots
= nslots
/ 63;
662 int direction
= nslots
< 0 ? -1 : 1;
664 new_addr
= addr
+ 8 * (nslots
+ mandatory_nat_slots
);
666 if ((new_addr
>> 9) != ((addr
+ 8 * 64 * mandatory_nat_slots
) >> 9))
667 new_addr
+= 8 * direction
;
669 if (IS_NaT_COLLECTION_ADDR(new_addr
))
670 new_addr
+= 8 * direction
;
675 /* The IA-64 frame chain is a bit odd. We won't always have a frame
676 pointer, so we use the SP value as the FP for the purpose of
677 creating a frame. There is sometimes a register (not fixed) which
678 is used as a frame pointer. When this register exists, it is not
679 especially hard to determine which one is being used. It isn't
680 even really hard to compute the frame chain, but it can be
681 computationally expensive. So, instead of making life difficult
682 (and slow), we pick a more convenient representation of the frame
683 chain, knowing that we'll have to make some small adjustments in
684 other places. (E.g, note that read_fp() is actually read_sp() in
685 ia64_gdbarch_init() below.)
687 Okay, so what is the frame chain exactly? It'll be the SP value
688 at the time that the function in question was entered.
690 Note that this *should* actually the frame pointer for the current
691 function! But as I note above, if we were to attempt to find the
692 address of the beginning of the previous frame, we'd waste a lot
693 of cycles for no good reason. So instead, we simply choose to
694 represent the frame chain as the end of the previous frame instead
698 ia64_frame_chain (struct frame_info
*frame
)
700 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
701 return read_sigcontext_register (frame
, sp_regnum
);
702 else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
703 get_frame_base (frame
),
704 get_frame_base (frame
)))
705 return get_frame_base (frame
);
708 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
709 if (get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
])
710 return read_memory_integer (get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
], 8);
712 return (get_frame_base (frame
)
713 + get_frame_extra_info (frame
)->mem_stack_frame_size
);
718 ia64_frame_saved_pc (struct frame_info
*frame
)
720 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
721 return read_sigcontext_register (frame
, pc_regnum
);
722 else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
723 get_frame_base (frame
),
724 get_frame_base (frame
)))
725 return deprecated_read_register_dummy (get_frame_pc (frame
),
726 get_frame_base (frame
), pc_regnum
);
729 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
731 if (get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
])
732 return read_memory_integer (get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
], 8);
733 else if (get_next_frame (frame
)
734 && (get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
))
735 return read_sigcontext_register (get_next_frame (frame
), IA64_BR0_REGNUM
);
736 else /* either frameless, or not far enough along in the prologue... */
737 return ia64_saved_pc_after_call (frame
);
741 /* Limit the number of skipped non-prologue instructions since examining
742 of the prologue is expensive. */
743 static int max_skip_non_prologue_insns
= 10;
745 /* Given PC representing the starting address of a function, and
746 LIM_PC which is the (sloppy) limit to which to scan when looking
747 for a prologue, attempt to further refine this limit by using
748 the line data in the symbol table. If successful, a better guess
749 on where the prologue ends is returned, otherwise the previous
750 value of lim_pc is returned. TRUST_LIMIT is a pointer to a flag
751 which will be set to indicate whether the returned limit may be
752 used with no further scanning in the event that the function is
756 refine_prologue_limit (CORE_ADDR pc
, CORE_ADDR lim_pc
, int *trust_limit
)
758 struct symtab_and_line prologue_sal
;
759 CORE_ADDR start_pc
= pc
;
761 /* Start off not trusting the limit. */
764 prologue_sal
= find_pc_line (pc
, 0);
765 if (prologue_sal
.line
!= 0)
768 CORE_ADDR addr
= prologue_sal
.end
;
770 /* Handle the case in which compiler's optimizer/scheduler
771 has moved instructions into the prologue. We scan ahead
772 in the function looking for address ranges whose corresponding
773 line number is less than or equal to the first one that we
774 found for the function. (It can be less than when the
775 scheduler puts a body instruction before the first prologue
777 for (i
= 2 * max_skip_non_prologue_insns
;
778 i
> 0 && (lim_pc
== 0 || addr
< lim_pc
);
781 struct symtab_and_line sal
;
783 sal
= find_pc_line (addr
, 0);
786 if (sal
.line
<= prologue_sal
.line
787 && sal
.symtab
== prologue_sal
.symtab
)
794 if (lim_pc
== 0 || prologue_sal
.end
< lim_pc
)
796 lim_pc
= prologue_sal
.end
;
797 if (start_pc
== get_pc_function_start (lim_pc
))
804 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
805 || (8 <= (_regnum_) && (_regnum_) <= 11) \
806 || (14 <= (_regnum_) && (_regnum_) <= 31))
807 #define imm9(_instr_) \
808 ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
809 | (((_instr_) & 0x00008000000LL) >> 20) \
810 | (((_instr_) & 0x00000001fc0LL) >> 6))
813 examine_prologue (CORE_ADDR pc
, CORE_ADDR lim_pc
, struct frame_info
*frame
)
816 CORE_ADDR last_prologue_pc
= pc
;
819 int do_fsr_stuff
= 0;
824 int unat_save_reg
= 0;
826 int mem_stack_frame_size
= 0;
828 CORE_ADDR spill_addr
= 0;
833 memset (instores
, 0, sizeof instores
);
834 memset (infpstores
, 0, sizeof infpstores
);
836 if (frame
&& !get_frame_saved_regs (frame
))
838 frame_saved_regs_zalloc (frame
);
844 && get_frame_extra_info (frame
)->after_prologue
!= 0
845 && get_frame_extra_info (frame
)->after_prologue
<= lim_pc
)
846 return get_frame_extra_info (frame
)->after_prologue
;
848 lim_pc
= refine_prologue_limit (pc
, lim_pc
, &trust_limit
);
850 /* Must start with an alloc instruction */
851 next_pc
= fetch_instruction (pc
, &it
, &instr
);
852 if (pc
< lim_pc
&& next_pc
853 && it
== M
&& ((instr
& 0x1ee0000003fLL
) == 0x02c00000000LL
))
856 int sor
= (int) ((instr
& 0x00078000000LL
) >> 27);
857 int sol
= (int) ((instr
& 0x00007f00000LL
) >> 20);
858 int sof
= (int) ((instr
& 0x000000fe000LL
) >> 13);
859 /* Okay, so sor, sol, and sof aren't used right now; but perhaps
860 we could compare against the size given to us via the cfm as
861 either a sanity check or possibly to see if the frame has been
862 changed by a later alloc instruction... */
863 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
865 last_prologue_pc
= next_pc
;
870 pc
= lim_pc
; /* Frameless: We're done early. */
872 last_prologue_pc
= lim_pc
;
875 /* Loop, looking for prologue instructions, keeping track of
876 where preserved registers were spilled. */
879 next_pc
= fetch_instruction (pc
, &it
, &instr
);
883 if ((it
== B
&& ((instr
& 0x1e1f800003f) != 0x04000000000))
884 || ((instr
& 0x3fLL
) != 0LL))
886 /* Exit loop upon hitting a non-nop branch instruction
887 or a predicated instruction. */
890 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00188000000LL
))
893 int b2
= (int) ((instr
& 0x0000000e000LL
) >> 13);
894 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
895 int qp
= (int) (instr
& 0x0000000003f);
897 if (qp
== 0 && b2
== 0 && rN
>= 32 && ret_reg
== 0)
900 last_prologue_pc
= next_pc
;
903 else if ((it
== I
|| it
== M
)
904 && ((instr
& 0x1ee00000000LL
) == 0x10800000000LL
))
906 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
907 int imm
= (int) ((((instr
& 0x01000000000LL
) ? -1 : 0) << 13)
908 | ((instr
& 0x001f8000000LL
) >> 20)
909 | ((instr
& 0x000000fe000LL
) >> 13));
910 int rM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
911 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
912 int qp
= (int) (instr
& 0x0000000003fLL
);
914 if (qp
== 0 && rN
>= 32 && imm
== 0 && rM
== 12 && fp_reg
== 0)
918 last_prologue_pc
= next_pc
;
920 else if (qp
== 0 && rN
== 12 && rM
== 12)
922 /* adds r12, -mem_stack_frame_size, r12 */
923 mem_stack_frame_size
-= imm
;
924 last_prologue_pc
= next_pc
;
926 else if (qp
== 0 && rN
== 2
927 && ((rM
== fp_reg
&& fp_reg
!= 0) || rM
== 12))
929 /* adds r2, spilloffset, rFramePointer
931 adds r2, spilloffset, r12
933 Get ready for stf.spill or st8.spill instructions.
934 The address to start spilling at is loaded into r2.
935 FIXME: Why r2? That's what gcc currently uses; it
936 could well be different for other compilers. */
938 /* Hmm... whether or not this will work will depend on
939 where the pc is. If it's still early in the prologue
940 this'll be wrong. FIXME */
941 spill_addr
= (frame
? get_frame_base (frame
) : 0)
942 + (rM
== 12 ? 0 : mem_stack_frame_size
)
945 last_prologue_pc
= next_pc
;
949 && ( ((instr
& 0x1efc0000000LL
) == 0x0eec0000000LL
)
950 || ((instr
& 0x1ffc8000000LL
) == 0x0cec0000000LL
) ))
952 /* stf.spill [rN] = fM, imm9
954 stf.spill [rN] = fM */
956 int imm
= imm9(instr
);
957 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
958 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
959 int qp
= (int) (instr
& 0x0000000003fLL
);
960 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
961 && ((2 <= fM
&& fM
<= 5) || (16 <= fM
&& fM
<= 31)))
964 get_frame_saved_regs (frame
)[IA64_FR0_REGNUM
+ fM
] = spill_addr
;
966 if ((instr
& 0x1efc0000000) == 0x0eec0000000)
969 spill_addr
= 0; /* last one; must be done */
970 last_prologue_pc
= next_pc
;
973 else if ((it
== M
&& ((instr
& 0x1eff8000000LL
) == 0x02110000000LL
))
974 || (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00050000000LL
)) )
980 int arM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
981 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
982 int qp
= (int) (instr
& 0x0000000003fLL
);
983 if (qp
== 0 && isScratch (rN
) && arM
== 36 /* ar.unat */)
985 /* We have something like "mov.m r3 = ar.unat". Remember the
986 r3 (or whatever) and watch for a store of this register... */
988 last_prologue_pc
= next_pc
;
991 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00198000000LL
))
994 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
995 int qp
= (int) (instr
& 0x0000000003fLL
);
996 if (qp
== 0 && isScratch (rN
))
999 last_prologue_pc
= next_pc
;
1003 && ( ((instr
& 0x1ffc8000000LL
) == 0x08cc0000000LL
)
1004 || ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)))
1008 st8 [rN] = rM, imm9 */
1009 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1010 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1011 int qp
= (int) (instr
& 0x0000000003fLL
);
1012 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
1013 && (rM
== unat_save_reg
|| rM
== pr_save_reg
))
1015 /* We've found a spill of either the UNAT register or the PR
1016 register. (Well, not exactly; what we've actually found is
1017 a spill of the register that UNAT or PR was moved to).
1018 Record that fact and move on... */
1019 if (rM
== unat_save_reg
)
1021 /* Track UNAT register */
1023 get_frame_saved_regs (frame
)[IA64_UNAT_REGNUM
] = spill_addr
;
1028 /* Track PR register */
1030 get_frame_saved_regs (frame
)[IA64_PR_REGNUM
] = spill_addr
;
1033 if ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)
1034 /* st8 [rN] = rM, imm9 */
1035 spill_addr
+= imm9(instr
);
1037 spill_addr
= 0; /* must be done spilling */
1038 last_prologue_pc
= next_pc
;
1040 else if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1042 /* Allow up to one store of each input register. */
1043 instores
[rM
-32] = 1;
1044 last_prologue_pc
= next_pc
;
1047 else if (it
== M
&& ((instr
& 0x1ff08000000LL
) == 0x08c00000000LL
))
1054 Note that the st8 case is handled in the clause above.
1056 Advance over stores of input registers. One store per input
1057 register is permitted. */
1058 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1059 int qp
= (int) (instr
& 0x0000000003fLL
);
1060 if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1062 instores
[rM
-32] = 1;
1063 last_prologue_pc
= next_pc
;
1066 else if (it
== M
&& ((instr
& 0x1ff88000000LL
) == 0x0cc80000000LL
))
1073 Advance over stores of floating point input registers. Again
1074 one store per register is permitted */
1075 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1076 int qp
= (int) (instr
& 0x0000000003fLL
);
1077 if (qp
== 0 && 8 <= fM
&& fM
< 16 && !infpstores
[fM
- 8])
1079 infpstores
[fM
-8] = 1;
1080 last_prologue_pc
= next_pc
;
1084 && ( ((instr
& 0x1ffc8000000LL
) == 0x08ec0000000LL
)
1085 || ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)))
1087 /* st8.spill [rN] = rM
1089 st8.spill [rN] = rM, imm9 */
1090 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1091 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1092 int qp
= (int) (instr
& 0x0000000003fLL
);
1093 if (qp
== 0 && rN
== spill_reg
&& 4 <= rM
&& rM
<= 7)
1095 /* We've found a spill of one of the preserved general purpose
1096 regs. Record the spill address and advance the spill
1097 register if appropriate. */
1099 get_frame_saved_regs (frame
)[IA64_GR0_REGNUM
+ rM
] = spill_addr
;
1100 if ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)
1101 /* st8.spill [rN] = rM, imm9 */
1102 spill_addr
+= imm9(instr
);
1104 spill_addr
= 0; /* Done spilling */
1105 last_prologue_pc
= next_pc
;
1117 /* Extract the size of the rotating portion of the stack
1118 frame and the register rename base from the current
1120 sor
= ((get_frame_extra_info (frame
)->cfm
>> 14) & 0xf) * 8;
1121 rrb_gr
= (get_frame_extra_info (frame
)->cfm
>> 18) & 0x7f;
1123 for (i
= 0, addr
= get_frame_extra_info (frame
)->bsp
;
1124 i
< get_frame_extra_info (frame
)->sof
;
1127 if (IS_NaT_COLLECTION_ADDR (addr
))
1132 get_frame_saved_regs (frame
)[IA64_GR32_REGNUM
+ ((i
+ (sor
- rrb_gr
)) % sor
)]
1135 get_frame_saved_regs (frame
)[IA64_GR32_REGNUM
+ i
] = addr
;
1137 if (i
+32 == cfm_reg
)
1138 get_frame_saved_regs (frame
)[IA64_CFM_REGNUM
] = addr
;
1139 if (i
+32 == ret_reg
)
1140 get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
] = addr
;
1142 get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
] = addr
;
1146 if (frame
&& get_frame_extra_info (frame
))
1148 get_frame_extra_info (frame
)->after_prologue
= last_prologue_pc
;
1149 get_frame_extra_info (frame
)->mem_stack_frame_size
= mem_stack_frame_size
;
1150 get_frame_extra_info (frame
)->fp_reg
= fp_reg
;
1153 return last_prologue_pc
;
1157 ia64_skip_prologue (CORE_ADDR pc
)
1159 return examine_prologue (pc
, pc
+1024, 0);
1163 ia64_frame_init_saved_regs (struct frame_info
*frame
)
1165 if (get_frame_saved_regs (frame
))
1168 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
) && SIGCONTEXT_REGISTER_ADDRESS
)
1172 frame_saved_regs_zalloc (frame
);
1174 get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
] =
1175 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_IP_REGNUM
);
1176 get_frame_saved_regs (frame
)[IA64_CFM_REGNUM
] =
1177 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_CFM_REGNUM
);
1178 get_frame_saved_regs (frame
)[IA64_PSR_REGNUM
] =
1179 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_PSR_REGNUM
);
1181 get_frame_saved_regs (frame
)[IA64_BSP_REGNUM
] =
1182 SIGCONTEXT_REGISTER_ADDRESS (frame
->frame
, IA64_BSP_REGNUM
);
1184 get_frame_saved_regs (frame
)[IA64_RNAT_REGNUM
] =
1185 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_RNAT_REGNUM
);
1186 get_frame_saved_regs (frame
)[IA64_CCV_REGNUM
] =
1187 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_CCV_REGNUM
);
1188 get_frame_saved_regs (frame
)[IA64_UNAT_REGNUM
] =
1189 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_UNAT_REGNUM
);
1190 get_frame_saved_regs (frame
)[IA64_FPSR_REGNUM
] =
1191 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_FPSR_REGNUM
);
1192 get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
] =
1193 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_PFS_REGNUM
);
1194 get_frame_saved_regs (frame
)[IA64_LC_REGNUM
] =
1195 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_LC_REGNUM
);
1196 for (regno
= IA64_GR1_REGNUM
; regno
<= IA64_GR31_REGNUM
; regno
++)
1197 if (regno
!= sp_regnum
)
1198 get_frame_saved_regs (frame
)[regno
] =
1199 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1200 for (regno
= IA64_BR0_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
1201 get_frame_saved_regs (frame
)[regno
] =
1202 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1203 for (regno
= IA64_FR2_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
1204 get_frame_saved_regs (frame
)[regno
] =
1205 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1209 CORE_ADDR func_start
;
1211 func_start
= get_pc_function_start (get_frame_pc (frame
));
1212 examine_prologue (func_start
, get_frame_pc (frame
), frame
);
1217 ia64_get_saved_register (char *raw_buffer
,
1220 struct frame_info
*frame
,
1222 enum lval_type
*lval
)
1226 if (!target_has_registers
)
1227 error ("No registers.");
1229 if (optimized
!= NULL
)
1238 is_dummy_frame
= DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
1239 get_frame_base (frame
),
1240 get_frame_base (frame
));
1242 if (regnum
== SP_REGNUM
&& get_next_frame (frame
))
1244 /* Handle SP values for all frames but the topmost. */
1245 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1246 get_frame_base (frame
));
1248 else if (regnum
== IA64_BSP_REGNUM
)
1250 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1251 get_frame_extra_info (frame
)->bsp
);
1253 else if (regnum
== IA64_VFP_REGNUM
)
1255 /* If the function in question uses an automatic register (r32-r127)
1256 for the frame pointer, it'll be found by ia64_find_saved_register()
1257 above. If the function lacks one of these frame pointers, we can
1258 still provide a value since we know the size of the frame */
1259 CORE_ADDR vfp
= (get_frame_base (frame
)
1260 + get_frame_extra_info (frame
)->mem_stack_frame_size
);
1261 store_address (raw_buffer
, REGISTER_RAW_SIZE (IA64_VFP_REGNUM
), vfp
);
1263 else if (IA64_PR0_REGNUM
<= regnum
&& regnum
<= IA64_PR63_REGNUM
)
1265 char *pr_raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
1267 enum lval_type pr_lval
;
1270 ia64_get_saved_register (pr_raw_buffer
, &pr_optim
, &pr_addr
,
1271 frame
, IA64_PR_REGNUM
, &pr_lval
);
1272 if (IA64_PR16_REGNUM
<= regnum
&& regnum
<= IA64_PR63_REGNUM
)
1274 /* Fetch predicate register rename base from current frame
1275 marker for this frame. */
1276 int rrb_pr
= (get_frame_extra_info (frame
)->cfm
>> 32) & 0x3f;
1278 /* Adjust the register number to account for register rotation. */
1279 regnum
= IA64_PR16_REGNUM
1280 + ((regnum
- IA64_PR16_REGNUM
) + rrb_pr
) % 48;
1282 prN_val
= extract_bit_field ((unsigned char *) pr_raw_buffer
,
1283 regnum
- IA64_PR0_REGNUM
, 1);
1284 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), prN_val
);
1286 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT31_REGNUM
)
1288 char *unat_raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
1290 enum lval_type unat_lval
;
1291 CORE_ADDR unat_addr
;
1293 ia64_get_saved_register (unat_raw_buffer
, &unat_optim
, &unat_addr
,
1294 frame
, IA64_UNAT_REGNUM
, &unat_lval
);
1295 unatN_val
= extract_bit_field ((unsigned char *) unat_raw_buffer
,
1296 regnum
- IA64_NAT0_REGNUM
, 1);
1297 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1300 else if (IA64_NAT32_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
1303 /* Find address of general register corresponding to nat bit we're
1305 CORE_ADDR gr_addr
= 0;
1307 if (!is_dummy_frame
)
1309 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1310 gr_addr
= get_frame_saved_regs (frame
)[ regnum
- IA64_NAT0_REGNUM
1315 /* Compute address of nat collection bits */
1316 CORE_ADDR nat_addr
= gr_addr
| 0x1f8;
1317 CORE_ADDR bsp
= read_register (IA64_BSP_REGNUM
);
1318 CORE_ADDR nat_collection
;
1320 /* If our nat collection address is bigger than bsp, we have to get
1321 the nat collection from rnat. Otherwise, we fetch the nat
1322 collection from the computed address. */
1323 if (nat_addr
>= bsp
)
1324 nat_collection
= read_register (IA64_RNAT_REGNUM
);
1326 nat_collection
= read_memory_integer (nat_addr
, 8);
1327 nat_bit
= (gr_addr
>> 3) & 0x3f;
1328 natval
= (nat_collection
>> nat_bit
) & 1;
1330 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), natval
);
1332 else if (regnum
== IA64_IP_REGNUM
)
1335 if (get_next_frame (frame
))
1337 /* FIXME: Set *addrp, *lval when possible. */
1338 pc
= ia64_frame_saved_pc (get_next_frame (frame
));
1344 store_address (raw_buffer
, REGISTER_RAW_SIZE (IA64_IP_REGNUM
), pc
);
1346 else if (IA64_GR32_REGNUM
<= regnum
&& regnum
<= IA64_GR127_REGNUM
)
1349 if (!is_dummy_frame
)
1351 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1352 addr
= get_frame_saved_regs (frame
)[regnum
];
1358 *lval
= lval_memory
;
1361 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1365 /* r32 - r127 must be fetchable via memory. If they aren't,
1366 then the register is unavailable */
1367 memset (raw_buffer
, 0, REGISTER_RAW_SIZE (regnum
));
1372 if (IA64_FR32_REGNUM
<= regnum
&& regnum
<= IA64_FR127_REGNUM
)
1374 /* Fetch floating point register rename base from current
1375 frame marker for this frame. */
1376 int rrb_fr
= (get_frame_extra_info (frame
)->cfm
>> 25) & 0x7f;
1378 /* Adjust the floating point register number to account for
1379 register rotation. */
1380 regnum
= IA64_FR32_REGNUM
1381 + ((regnum
- IA64_FR32_REGNUM
) + rrb_fr
) % 96;
1384 deprecated_generic_get_saved_register (raw_buffer
, optimized
, addrp
,
1385 frame
, regnum
, lval
);
1389 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1390 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1391 and TYPE is the type (which is known to be struct, union or array). */
1393 ia64_use_struct_convention (int gcc_p
, struct type
*type
)
1395 struct type
*float_elt_type
;
1397 /* HFAs are structures (or arrays) consisting entirely of floating
1398 point values of the same length. Up to 8 of these are returned
1399 in registers. Don't use the struct convention when this is the
1401 float_elt_type
= is_float_or_hfa_type (type
);
1402 if (float_elt_type
!= NULL
1403 && TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
) <= 8)
1406 /* Other structs of length 32 or less are returned in r8-r11.
1407 Don't use the struct convention for those either. */
1408 return TYPE_LENGTH (type
) > 32;
1412 ia64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
1414 struct type
*float_elt_type
;
1416 float_elt_type
= is_float_or_hfa_type (type
);
1417 if (float_elt_type
!= NULL
)
1420 int regnum
= IA64_FR8_REGNUM
;
1421 int n
= TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
);
1425 ia64_register_convert_to_virtual (regnum
, float_elt_type
,
1426 ®buf
[REGISTER_BYTE (regnum
)], valbuf
+ offset
);
1427 offset
+= TYPE_LENGTH (float_elt_type
);
1432 memcpy (valbuf
, ®buf
[REGISTER_BYTE (IA64_GR8_REGNUM
)],
1433 TYPE_LENGTH (type
));
1436 /* FIXME: Turn this into a stack of some sort. Unfortunately, something
1437 like this is necessary though since the IA-64 calling conventions specify
1438 that r8 is not preserved. */
1439 static CORE_ADDR struct_return_address
;
1442 ia64_extract_struct_value_address (char *regbuf
)
1444 /* FIXME: See above. */
1445 return struct_return_address
;
1449 ia64_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1451 /* FIXME: See above. */
1452 /* Note that most of the work was done in ia64_push_arguments() */
1453 struct_return_address
= addr
;
1457 ia64_frameless_function_invocation (struct frame_info
*frame
)
1459 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1460 return (get_frame_extra_info (frame
)->mem_stack_frame_size
== 0);
1464 ia64_saved_pc_after_call (struct frame_info
*frame
)
1466 return read_register (IA64_BR0_REGNUM
);
1470 ia64_frame_args_address (struct frame_info
*frame
)
1472 /* frame->frame points at the SP for this frame; But we want the start
1473 of the frame, not the end. Calling frame chain will get his for us. */
1474 return ia64_frame_chain (frame
);
1478 ia64_frame_locals_address (struct frame_info
*frame
)
1480 /* frame->frame points at the SP for this frame; But we want the start
1481 of the frame, not the end. Calling frame chain will get his for us. */
1482 return ia64_frame_chain (frame
);
1486 ia64_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
1489 int next_frame_is_call_dummy
= ((get_next_frame (frame
) != NULL
)
1490 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frame
)),
1491 get_frame_base (get_next_frame (frame
)),
1492 get_frame_base (get_next_frame (frame
))));
1494 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
1496 if (get_next_frame (frame
) == 0)
1498 bsp
= read_register (IA64_BSP_REGNUM
);
1499 cfm
= read_register (IA64_CFM_REGNUM
);
1502 else if ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
))
1504 bsp
= read_sigcontext_register (get_next_frame (frame
), IA64_BSP_REGNUM
);
1505 cfm
= read_sigcontext_register (get_next_frame (frame
), IA64_CFM_REGNUM
);
1507 else if (next_frame_is_call_dummy
)
1509 bsp
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame
)),
1510 get_frame_base (get_next_frame (frame
)),
1512 cfm
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame
)),
1513 get_frame_base (get_next_frame (frame
)),
1518 struct frame_info
*frn
= get_next_frame (frame
);
1520 DEPRECATED_FRAME_INIT_SAVED_REGS (frn
);
1522 if (get_frame_saved_regs (frn
)[IA64_CFM_REGNUM
] != 0)
1523 cfm
= read_memory_integer (get_frame_saved_regs (frn
)[IA64_CFM_REGNUM
], 8);
1524 else if (get_next_frame (frn
) && (get_frame_type (get_next_frame (frn
)) == SIGTRAMP_FRAME
))
1525 cfm
= read_sigcontext_register (get_next_frame (frn
), IA64_PFS_REGNUM
);
1526 else if (get_next_frame (frn
)
1527 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frn
)),
1528 get_frame_base (get_next_frame (frn
)),
1529 get_frame_base (get_next_frame (frn
))))
1530 cfm
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frn
)),
1531 get_frame_base (get_next_frame (frn
)),
1534 cfm
= read_register (IA64_PFS_REGNUM
);
1536 bsp
= get_frame_extra_info (frn
)->bsp
;
1538 get_frame_extra_info (frame
)->cfm
= cfm
;
1539 get_frame_extra_info (frame
)->sof
= cfm
& 0x7f;
1540 get_frame_extra_info (frame
)->sol
= (cfm
>> 7) & 0x7f;
1541 if (get_next_frame (frame
) == 0
1542 || (get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
)
1543 || next_frame_is_call_dummy
)
1544 get_frame_extra_info (frame
)->bsp
=
1545 rse_address_add (bsp
, -get_frame_extra_info (frame
)->sof
);
1547 get_frame_extra_info (frame
)->bsp
=
1548 rse_address_add (bsp
, -get_frame_extra_info (frame
)->sol
);
1550 get_frame_extra_info (frame
)->after_prologue
= 0;
1551 get_frame_extra_info (frame
)->mem_stack_frame_size
= -1; /* Not yet determined */
1552 get_frame_extra_info (frame
)->fp_reg
= 0;
1556 is_float_or_hfa_type_recurse (struct type
*t
, struct type
**etp
)
1558 switch (TYPE_CODE (t
))
1562 return TYPE_LENGTH (*etp
) == TYPE_LENGTH (t
);
1569 case TYPE_CODE_ARRAY
:
1571 is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t
)),
1574 case TYPE_CODE_STRUCT
:
1578 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
1579 if (!is_float_or_hfa_type_recurse
1580 (check_typedef (TYPE_FIELD_TYPE (t
, i
)), etp
))
1591 /* Determine if the given type is one of the floating point types or
1592 and HFA (which is a struct, array, or combination thereof whose
1593 bottom-most elements are all of the same floating point type.) */
1595 static struct type
*
1596 is_float_or_hfa_type (struct type
*t
)
1598 struct type
*et
= 0;
1600 return is_float_or_hfa_type_recurse (t
, &et
) ? et
: 0;
1604 /* Return 1 if the alignment of T is such that the next even slot
1605 should be used. Return 0, if the next available slot should
1606 be used. (See section 8.5.1 of the IA-64 Software Conventions
1607 and Runtime manual.) */
1610 slot_alignment_is_next_even (struct type
*t
)
1612 switch (TYPE_CODE (t
))
1616 if (TYPE_LENGTH (t
) > 8)
1620 case TYPE_CODE_ARRAY
:
1622 slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t
)));
1623 case TYPE_CODE_STRUCT
:
1627 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
1628 if (slot_alignment_is_next_even
1629 (check_typedef (TYPE_FIELD_TYPE (t
, i
))))
1638 /* Attempt to find (and return) the global pointer for the given
1641 This is a rather nasty bit of code searchs for the .dynamic section
1642 in the objfile corresponding to the pc of the function we're trying
1643 to call. Once it finds the addresses at which the .dynamic section
1644 lives in the child process, it scans the Elf64_Dyn entries for a
1645 DT_PLTGOT tag. If it finds one of these, the corresponding
1646 d_un.d_ptr value is the global pointer. */
1649 generic_elf_find_global_pointer (CORE_ADDR faddr
)
1651 struct obj_section
*faddr_sect
;
1653 faddr_sect
= find_pc_section (faddr
);
1654 if (faddr_sect
!= NULL
)
1656 struct obj_section
*osect
;
1658 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
1660 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
1664 if (osect
< faddr_sect
->objfile
->sections_end
)
1669 while (addr
< osect
->endaddr
)
1675 status
= target_read_memory (addr
, buf
, sizeof (buf
));
1678 tag
= extract_signed_integer (buf
, sizeof (buf
));
1680 if (tag
== DT_PLTGOT
)
1682 CORE_ADDR global_pointer
;
1684 status
= target_read_memory (addr
+ 8, buf
, sizeof (buf
));
1687 global_pointer
= extract_address (buf
, sizeof (buf
));
1690 return global_pointer
;
1703 /* Given a function's address, attempt to find (and return) the
1704 corresponding (canonical) function descriptor. Return 0 if
1707 find_extant_func_descr (CORE_ADDR faddr
)
1709 struct obj_section
*faddr_sect
;
1711 /* Return early if faddr is already a function descriptor */
1712 faddr_sect
= find_pc_section (faddr
);
1713 if (faddr_sect
&& strcmp (faddr_sect
->the_bfd_section
->name
, ".opd") == 0)
1716 if (faddr_sect
!= NULL
)
1718 struct obj_section
*osect
;
1719 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
1721 if (strcmp (osect
->the_bfd_section
->name
, ".opd") == 0)
1725 if (osect
< faddr_sect
->objfile
->sections_end
)
1730 while (addr
< osect
->endaddr
)
1736 status
= target_read_memory (addr
, buf
, sizeof (buf
));
1739 faddr2
= extract_signed_integer (buf
, sizeof (buf
));
1741 if (faddr
== faddr2
)
1751 /* Attempt to find a function descriptor corresponding to the
1752 given address. If none is found, construct one on the
1753 stack using the address at fdaptr */
1756 find_func_descr (CORE_ADDR faddr
, CORE_ADDR
*fdaptr
)
1760 fdesc
= find_extant_func_descr (faddr
);
1764 CORE_ADDR global_pointer
;
1770 global_pointer
= FIND_GLOBAL_POINTER (faddr
);
1772 if (global_pointer
== 0)
1773 global_pointer
= read_register (IA64_GR1_REGNUM
);
1775 store_address (buf
, 8, faddr
);
1776 store_address (buf
+ 8, 8, global_pointer
);
1778 write_memory (fdesc
, buf
, 16);
1785 ia64_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1786 int struct_return
, CORE_ADDR struct_addr
)
1792 int nslots
, rseslots
, memslots
, slotnum
, nfuncargs
;
1794 CORE_ADDR bsp
, cfm
, pfs
, new_bsp
, funcdescaddr
;
1798 /* Count the number of slots needed for the arguments */
1799 for (argno
= 0; argno
< nargs
; argno
++)
1802 type
= check_typedef (VALUE_TYPE (arg
));
1803 len
= TYPE_LENGTH (type
);
1805 if ((nslots
& 1) && slot_alignment_is_next_even (type
))
1808 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1811 nslots
+= (len
+ 7) / 8;
1814 /* Divvy up the slots between the RSE and the memory stack */
1815 rseslots
= (nslots
> 8) ? 8 : nslots
;
1816 memslots
= nslots
- rseslots
;
1818 /* Allocate a new RSE frame */
1819 cfm
= read_register (IA64_CFM_REGNUM
);
1821 bsp
= read_register (IA64_BSP_REGNUM
);
1822 bsp
= rse_address_add (bsp
, cfm
& 0x7f);
1823 new_bsp
= rse_address_add (bsp
, rseslots
);
1824 write_register (IA64_BSP_REGNUM
, new_bsp
);
1826 pfs
= read_register (IA64_PFS_REGNUM
);
1827 pfs
&= 0xc000000000000000LL
;
1828 pfs
|= (cfm
& 0xffffffffffffLL
);
1829 write_register (IA64_PFS_REGNUM
, pfs
);
1831 cfm
&= 0xc000000000000000LL
;
1833 write_register (IA64_CFM_REGNUM
, cfm
);
1835 /* We will attempt to find function descriptors in the .opd segment,
1836 but if we can't we'll construct them ourselves. That being the
1837 case, we'll need to reserve space on the stack for them. */
1838 funcdescaddr
= sp
- nfuncargs
* 16;
1839 funcdescaddr
&= ~0xfLL
;
1841 /* Adjust the stack pointer to it's new value. The calling conventions
1842 require us to have 16 bytes of scratch, plus whatever space is
1843 necessary for the memory slots and our function descriptors */
1844 sp
= sp
- 16 - (memslots
+ nfuncargs
) * 8;
1845 sp
&= ~0xfLL
; /* Maintain 16 byte alignment */
1847 /* Place the arguments where they belong. The arguments will be
1848 either placed in the RSE backing store or on the memory stack.
1849 In addition, floating point arguments or HFAs are placed in
1850 floating point registers. */
1852 floatreg
= IA64_FR8_REGNUM
;
1853 for (argno
= 0; argno
< nargs
; argno
++)
1855 struct type
*float_elt_type
;
1858 type
= check_typedef (VALUE_TYPE (arg
));
1859 len
= TYPE_LENGTH (type
);
1861 /* Special handling for function parameters */
1863 && TYPE_CODE (type
) == TYPE_CODE_PTR
1864 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1868 store_address (val_buf
, 8,
1869 find_func_descr (extract_address (VALUE_CONTENTS (arg
), 8),
1871 if (slotnum
< rseslots
)
1872 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
1874 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
1881 /* Skip odd slot if necessary... */
1882 if ((slotnum
& 1) && slot_alignment_is_next_even (type
))
1890 memset (val_buf
, 0, 8);
1891 memcpy (val_buf
, VALUE_CONTENTS (arg
) + argoffset
, (len
> 8) ? 8 : len
);
1893 if (slotnum
< rseslots
)
1894 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
1896 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
1903 /* Handle floating point types (including HFAs) */
1904 float_elt_type
= is_float_or_hfa_type (type
);
1905 if (float_elt_type
!= NULL
)
1908 len
= TYPE_LENGTH (type
);
1909 while (len
> 0 && floatreg
< IA64_FR16_REGNUM
)
1911 ia64_register_convert_to_raw (
1914 VALUE_CONTENTS (arg
) + argoffset
,
1915 &deprecated_registers
[REGISTER_BYTE (floatreg
)]);
1917 argoffset
+= TYPE_LENGTH (float_elt_type
);
1918 len
-= TYPE_LENGTH (float_elt_type
);
1923 /* Store the struct return value in r8 if necessary. */
1926 store_address (&deprecated_registers
[REGISTER_BYTE (IA64_GR8_REGNUM
)],
1927 REGISTER_RAW_SIZE (IA64_GR8_REGNUM
),
1931 /* Sync gdb's idea of what the registers are with the target. */
1932 target_store_registers (-1);
1934 /* FIXME: This doesn't belong here! Instead, SAVE_DUMMY_FRAME_TOS needs
1935 to be defined to call generic_save_dummy_frame_tos(). But at the
1936 time of this writing, SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so
1937 I chose to put this call here instead of using the old mechanisms.
1938 Once SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do is add the
1941 set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1943 to ia64_gdbarch_init() and remove the line below. */
1944 generic_save_dummy_frame_tos (sp
);
1950 ia64_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1952 CORE_ADDR global_pointer
= FIND_GLOBAL_POINTER (pc
);
1954 if (global_pointer
!= 0)
1955 write_register (IA64_GR1_REGNUM
, global_pointer
);
1957 write_register (IA64_BR0_REGNUM
, CALL_DUMMY_ADDRESS ());
1962 ia64_store_return_value (struct type
*type
, char *valbuf
)
1964 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1966 ia64_register_convert_to_raw (type
, IA64_FR8_REGNUM
, valbuf
,
1967 &deprecated_registers
[REGISTER_BYTE (IA64_FR8_REGNUM
)]);
1968 target_store_registers (IA64_FR8_REGNUM
);
1971 deprecated_write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM
),
1972 valbuf
, TYPE_LENGTH (type
));
1976 ia64_pop_frame (void)
1978 generic_pop_current_frame (ia64_pop_frame_regular
);
1982 ia64_pop_frame_regular (struct frame_info
*frame
)
1985 CORE_ADDR bsp
, cfm
, pfs
;
1987 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1989 for (regno
= 0; regno
< ia64_num_regs
; regno
++)
1991 if (get_frame_saved_regs (frame
)[regno
]
1992 && (!(IA64_GR32_REGNUM
<= regno
&& regno
<= IA64_GR127_REGNUM
))
1993 && regno
!= pc_regnum
1994 && regno
!= sp_regnum
1995 && regno
!= IA64_PFS_REGNUM
1996 && regno
!= IA64_CFM_REGNUM
1997 && regno
!= IA64_BSP_REGNUM
1998 && regno
!= IA64_BSPSTORE_REGNUM
)
2000 write_register (regno
,
2001 read_memory_integer (get_frame_saved_regs (frame
)[regno
],
2002 REGISTER_RAW_SIZE (regno
)));
2006 write_register (sp_regnum
, DEPRECATED_FRAME_CHAIN (frame
));
2007 write_pc (DEPRECATED_FRAME_SAVED_PC (frame
));
2009 cfm
= read_register (IA64_CFM_REGNUM
);
2011 if (get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
])
2013 pfs
= read_memory_integer (get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
],
2014 REGISTER_RAW_SIZE (IA64_PFS_REGNUM
));
2017 pfs
= read_register (IA64_PFS_REGNUM
);
2019 /* Compute the new bsp by *adding* the difference between the
2020 size of the frame and the size of the locals (both wrt the
2021 frame that we're going back to). This seems kind of strange,
2022 especially since it seems like we ought to be subtracting the
2023 size of the locals... and we should; but the Linux kernel
2024 wants bsp to be set at the end of all used registers. It's
2025 likely that this code will need to be revised to accomodate
2026 other operating systems. */
2027 bsp
= rse_address_add (get_frame_extra_info (frame
)->bsp
,
2028 (pfs
& 0x7f) - ((pfs
>> 7) & 0x7f));
2029 write_register (IA64_BSP_REGNUM
, bsp
);
2031 /* FIXME: What becomes of the epilog count in the PFS? */
2032 cfm
= (cfm
& ~0xffffffffffffLL
) | (pfs
& 0xffffffffffffLL
);
2033 write_register (IA64_CFM_REGNUM
, cfm
);
2035 flush_cached_frames ();
2039 ia64_remote_translate_xfer_address (CORE_ADDR memaddr
, int nr_bytes
,
2040 CORE_ADDR
*targ_addr
, int *targ_len
)
2042 *targ_addr
= memaddr
;
2043 *targ_len
= nr_bytes
;
2047 process_note_abi_tag_sections (bfd
*abfd
, asection
*sect
, void *obj
)
2049 int *os_ident_ptr
= obj
;
2051 unsigned int sectsize
;
2053 name
= bfd_get_section_name (abfd
, sect
);
2054 sectsize
= bfd_section_size (abfd
, sect
);
2055 if (strcmp (name
, ".note.ABI-tag") == 0 && sectsize
> 0)
2057 unsigned int name_length
, data_length
, note_type
;
2058 char *note
= alloca (sectsize
);
2060 bfd_get_section_contents (abfd
, sect
, note
,
2061 (file_ptr
) 0, (bfd_size_type
) sectsize
);
2063 name_length
= bfd_h_get_32 (abfd
, note
);
2064 data_length
= bfd_h_get_32 (abfd
, note
+ 4);
2065 note_type
= bfd_h_get_32 (abfd
, note
+ 8);
2067 if (name_length
== 4 && data_length
== 16 && note_type
== 1
2068 && strcmp (note
+ 12, "GNU") == 0)
2070 int os_number
= bfd_h_get_32 (abfd
, note
+ 16);
2072 /* The case numbers are from abi-tags in glibc */
2076 *os_ident_ptr
= ELFOSABI_LINUX
;
2079 *os_ident_ptr
= ELFOSABI_HURD
;
2082 *os_ident_ptr
= ELFOSABI_SOLARIS
;
2085 internal_error (__FILE__
, __LINE__
,
2086 "process_note_abi_sections: unknown OS number %d", os_number
);
2093 static struct gdbarch
*
2094 ia64_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2096 struct gdbarch
*gdbarch
;
2097 struct gdbarch_tdep
*tdep
;
2100 if (info
.abfd
!= NULL
2101 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
2103 os_ident
= elf_elfheader (info
.abfd
)->e_ident
[EI_OSABI
];
2105 /* If os_ident is 0, it is not necessarily the case that we're
2106 on a SYSV system. (ELFOSABI_NONE is defined to be 0.)
2107 GNU/Linux uses a note section to record OS/ABI info, but
2108 leaves e_ident[EI_OSABI] zero. So we have to check for note
2112 bfd_map_over_sections (info
.abfd
,
2113 process_note_abi_tag_sections
,
2120 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2122 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
2124 tdep
= gdbarch_tdep (arches
->gdbarch
);
2125 if (tdep
&&tdep
->os_ident
== os_ident
)
2126 return arches
->gdbarch
;
2129 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
2130 gdbarch
= gdbarch_alloc (&info
, tdep
);
2131 tdep
->os_ident
= os_ident
;
2133 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2134 ready to unwind the PC first (see frame.c:get_prev_frame()). */
2135 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
2137 /* Set the method of obtaining the sigcontext addresses at which
2138 registers are saved. The method of checking to see if
2139 native_find_global_pointer is nonzero to indicate that we're
2140 on AIX is kind of hokey, but I can't think of a better way
2142 if (os_ident
== ELFOSABI_LINUX
)
2143 tdep
->sigcontext_register_address
= ia64_linux_sigcontext_register_address
;
2144 else if (native_find_global_pointer
!= 0)
2145 tdep
->sigcontext_register_address
= ia64_aix_sigcontext_register_address
;
2147 tdep
->sigcontext_register_address
= 0;
2149 /* We know that GNU/Linux won't have to resort to the
2150 native_find_global_pointer hackery. But that's the only one we
2151 know about so far, so if native_find_global_pointer is set to
2152 something non-zero, then use it. Otherwise fall back to using
2153 generic_elf_find_global_pointer. This arrangement should (in
2154 theory) allow us to cross debug GNU/Linux binaries from an AIX
2156 if (os_ident
== ELFOSABI_LINUX
)
2157 tdep
->find_global_pointer
= generic_elf_find_global_pointer
;
2158 else if (native_find_global_pointer
!= 0)
2159 tdep
->find_global_pointer
= native_find_global_pointer
;
2161 tdep
->find_global_pointer
= generic_elf_find_global_pointer
;
2163 set_gdbarch_short_bit (gdbarch
, 16);
2164 set_gdbarch_int_bit (gdbarch
, 32);
2165 set_gdbarch_long_bit (gdbarch
, 64);
2166 set_gdbarch_long_long_bit (gdbarch
, 64);
2167 set_gdbarch_float_bit (gdbarch
, 32);
2168 set_gdbarch_double_bit (gdbarch
, 64);
2169 set_gdbarch_long_double_bit (gdbarch
, 64);
2170 set_gdbarch_ptr_bit (gdbarch
, 64);
2172 set_gdbarch_num_regs (gdbarch
, ia64_num_regs
);
2173 set_gdbarch_sp_regnum (gdbarch
, sp_regnum
);
2174 set_gdbarch_fp_regnum (gdbarch
, fp_regnum
);
2175 set_gdbarch_pc_regnum (gdbarch
, pc_regnum
);
2176 set_gdbarch_fp0_regnum (gdbarch
, IA64_FR0_REGNUM
);
2178 set_gdbarch_register_name (gdbarch
, ia64_register_name
);
2179 set_gdbarch_register_size (gdbarch
, 8);
2180 set_gdbarch_register_bytes (gdbarch
, ia64_num_regs
* 8 + 128*8);
2181 set_gdbarch_register_byte (gdbarch
, ia64_register_byte
);
2182 set_gdbarch_register_raw_size (gdbarch
, ia64_register_raw_size
);
2183 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 16);
2184 set_gdbarch_register_virtual_size (gdbarch
, ia64_register_virtual_size
);
2185 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 16);
2186 set_gdbarch_register_virtual_type (gdbarch
, ia64_register_virtual_type
);
2188 set_gdbarch_skip_prologue (gdbarch
, ia64_skip_prologue
);
2190 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
2191 set_gdbarch_frameless_function_invocation (gdbarch
, ia64_frameless_function_invocation
);
2193 set_gdbarch_saved_pc_after_call (gdbarch
, ia64_saved_pc_after_call
);
2195 set_gdbarch_deprecated_frame_chain (gdbarch
, ia64_frame_chain
);
2196 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, ia64_frame_saved_pc
);
2198 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, ia64_frame_init_saved_regs
);
2199 set_gdbarch_deprecated_get_saved_register (gdbarch
, ia64_get_saved_register
);
2201 set_gdbarch_register_convertible (gdbarch
, ia64_register_convertible
);
2202 set_gdbarch_register_convert_to_virtual (gdbarch
, ia64_register_convert_to_virtual
);
2203 set_gdbarch_register_convert_to_raw (gdbarch
, ia64_register_convert_to_raw
);
2205 set_gdbarch_use_struct_convention (gdbarch
, ia64_use_struct_convention
);
2206 set_gdbarch_deprecated_extract_return_value (gdbarch
, ia64_extract_return_value
);
2208 set_gdbarch_store_struct_return (gdbarch
, ia64_store_struct_return
);
2209 set_gdbarch_deprecated_store_return_value (gdbarch
, ia64_store_return_value
);
2210 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, ia64_extract_struct_value_address
);
2212 set_gdbarch_memory_insert_breakpoint (gdbarch
, ia64_memory_insert_breakpoint
);
2213 set_gdbarch_memory_remove_breakpoint (gdbarch
, ia64_memory_remove_breakpoint
);
2214 set_gdbarch_breakpoint_from_pc (gdbarch
, ia64_breakpoint_from_pc
);
2215 set_gdbarch_read_pc (gdbarch
, ia64_read_pc
);
2216 set_gdbarch_write_pc (gdbarch
, ia64_write_pc
);
2218 /* Settings for calling functions in the inferior. */
2219 set_gdbarch_call_dummy_length (gdbarch
, 0);
2220 set_gdbarch_push_arguments (gdbarch
, ia64_push_arguments
);
2221 set_gdbarch_push_return_address (gdbarch
, ia64_push_return_address
);
2222 set_gdbarch_deprecated_pop_frame (gdbarch
, ia64_pop_frame
);
2224 set_gdbarch_call_dummy_p (gdbarch
, 1);
2225 set_gdbarch_call_dummy_words (gdbarch
, ia64_call_dummy_words
);
2226 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof (ia64_call_dummy_words
));
2227 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
2228 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, ia64_init_extra_frame_info
);
2229 set_gdbarch_frame_args_address (gdbarch
, ia64_frame_args_address
);
2230 set_gdbarch_frame_locals_address (gdbarch
, ia64_frame_locals_address
);
2232 /* We won't necessarily have a frame pointer and even if we do,
2233 it winds up being extraordinarly messy when attempting to find
2234 the frame chain. So for the purposes of creating frames (which
2235 is all read_fp() is used for), simply use the stack pointer value
2237 set_gdbarch_read_fp (gdbarch
, generic_target_read_sp
);
2239 /* Settings that should be unnecessary. */
2240 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2242 set_gdbarch_read_sp (gdbarch
, generic_target_read_sp
);
2243 set_gdbarch_write_sp (gdbarch
, generic_target_write_sp
);
2245 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
2246 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
2247 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
2248 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
2249 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
2251 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
2252 set_gdbarch_function_start_offset (gdbarch
, 0);
2253 set_gdbarch_frame_args_skip (gdbarch
, 0);
2255 set_gdbarch_remote_translate_xfer_address (
2256 gdbarch
, ia64_remote_translate_xfer_address
);
2262 _initialize_ia64_tdep (void)
2264 register_gdbarch_init (bfd_arch_ia64
, ia64_gdbarch_init
);
2266 tm_print_insn
= print_insn_ia64
;
2267 tm_print_insn_info
.bytes_per_line
= SLOT_MULTIPLIER
;