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_push_arguments_ftype ia64_push_arguments
;
100 static gdbarch_push_return_address_ftype ia64_push_return_address
;
101 static gdbarch_saved_pc_after_call_ftype ia64_saved_pc_after_call
;
102 static void ia64_pop_frame_regular (struct frame_info
*frame
);
103 static struct type
*is_float_or_hfa_type (struct type
*t
);
105 static int ia64_num_regs
= 590;
107 static int pc_regnum
= IA64_IP_REGNUM
;
108 static int sp_regnum
= IA64_GR12_REGNUM
;
109 static int fp_regnum
= IA64_VFP_REGNUM
;
110 static int lr_regnum
= IA64_VRAP_REGNUM
;
112 static LONGEST ia64_call_dummy_words
[] = {0};
114 /* Array of register names; There should be ia64_num_regs strings in
117 static char *ia64_register_names
[] =
118 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
119 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
120 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
121 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
122 "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
123 "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
124 "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
125 "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
126 "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
127 "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
128 "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
129 "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
130 "r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
131 "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
132 "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
133 "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
135 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
136 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
137 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
138 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
139 "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
140 "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47",
141 "f48", "f49", "f50", "f51", "f52", "f53", "f54", "f55",
142 "f56", "f57", "f58", "f59", "f60", "f61", "f62", "f63",
143 "f64", "f65", "f66", "f67", "f68", "f69", "f70", "f71",
144 "f72", "f73", "f74", "f75", "f76", "f77", "f78", "f79",
145 "f80", "f81", "f82", "f83", "f84", "f85", "f86", "f87",
146 "f88", "f89", "f90", "f91", "f92", "f93", "f94", "f95",
147 "f96", "f97", "f98", "f99", "f100", "f101", "f102", "f103",
148 "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
149 "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
150 "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
152 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
153 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
154 "p16", "p17", "p18", "p19", "p20", "p21", "p22", "p23",
155 "p24", "p25", "p26", "p27", "p28", "p29", "p30", "p31",
156 "p32", "p33", "p34", "p35", "p36", "p37", "p38", "p39",
157 "p40", "p41", "p42", "p43", "p44", "p45", "p46", "p47",
158 "p48", "p49", "p50", "p51", "p52", "p53", "p54", "p55",
159 "p56", "p57", "p58", "p59", "p60", "p61", "p62", "p63",
161 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
165 "pr", "ip", "psr", "cfm",
167 "kr0", "kr1", "kr2", "kr3", "kr4", "kr5", "kr6", "kr7",
168 "", "", "", "", "", "", "", "",
169 "rsc", "bsp", "bspstore", "rnat",
171 "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr", "",
172 "ccv", "", "", "", "unat", "", "", "",
173 "fpsr", "", "", "", "itc",
174 "", "", "", "", "", "", "", "", "", "",
175 "", "", "", "", "", "", "", "", "",
177 "", "", "", "", "", "", "", "", "", "",
178 "", "", "", "", "", "", "", "", "", "",
179 "", "", "", "", "", "", "", "", "", "",
180 "", "", "", "", "", "", "", "", "", "",
181 "", "", "", "", "", "", "", "", "", "",
182 "", "", "", "", "", "", "", "", "", "",
184 "nat0", "nat1", "nat2", "nat3", "nat4", "nat5", "nat6", "nat7",
185 "nat8", "nat9", "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
186 "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
187 "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
188 "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
189 "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
190 "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
191 "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
192 "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
193 "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
194 "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
195 "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
196 "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
197 "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
198 "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
199 "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
202 struct frame_extra_info
204 CORE_ADDR bsp
; /* points at r32 for the current frame */
205 CORE_ADDR cfm
; /* cfm value for current frame */
206 int sof
; /* Size of frame (decoded from cfm value) */
207 int sol
; /* Size of locals (decoded from cfm value) */
208 CORE_ADDR after_prologue
;
209 /* Address of first instruction after the last
210 prologue instruction; Note that there may
211 be instructions from the function's body
212 intermingled with the prologue. */
213 int mem_stack_frame_size
;
214 /* Size of the memory stack frame (may be zero),
215 or -1 if it has not been determined yet. */
216 int fp_reg
; /* Register number (if any) used a frame pointer
217 for this frame. 0 if no register is being used
218 as the frame pointer. */
223 int os_ident
; /* From the ELF header, one of the ELFOSABI_
224 constants: ELFOSABI_LINUX, ELFOSABI_AIX,
226 CORE_ADDR (*sigcontext_register_address
) (CORE_ADDR
, int);
227 /* OS specific function which, given a frame address
228 and register number, returns the offset to the
229 given register from the start of the frame. */
230 CORE_ADDR (*find_global_pointer
) (CORE_ADDR
);
233 #define SIGCONTEXT_REGISTER_ADDRESS \
234 (gdbarch_tdep (current_gdbarch)->sigcontext_register_address)
235 #define FIND_GLOBAL_POINTER \
236 (gdbarch_tdep (current_gdbarch)->find_global_pointer)
239 ia64_register_name (int reg
)
241 return ia64_register_names
[reg
];
245 ia64_register_raw_size (int reg
)
247 return (IA64_FR0_REGNUM
<= reg
&& reg
<= IA64_FR127_REGNUM
) ? 16 : 8;
251 ia64_register_virtual_size (int reg
)
253 return (IA64_FR0_REGNUM
<= reg
&& reg
<= IA64_FR127_REGNUM
) ? 16 : 8;
256 /* Return true iff register N's virtual format is different from
259 ia64_register_convertible (int nr
)
261 return (IA64_FR0_REGNUM
<= nr
&& nr
<= IA64_FR127_REGNUM
);
264 const struct floatformat floatformat_ia64_ext
=
266 floatformat_little
, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
267 floatformat_intbit_yes
271 ia64_register_convert_to_virtual (int regnum
, struct type
*type
,
272 char *from
, char *to
)
274 if (regnum
>= IA64_FR0_REGNUM
&& regnum
<= IA64_FR127_REGNUM
)
277 floatformat_to_doublest (&floatformat_ia64_ext
, from
, &val
);
278 store_floating(to
, TYPE_LENGTH(type
), val
);
281 error("ia64_register_convert_to_virtual called with non floating point register number");
285 ia64_register_convert_to_raw (struct type
*type
, int regnum
,
286 char *from
, char *to
)
288 if (regnum
>= IA64_FR0_REGNUM
&& regnum
<= IA64_FR127_REGNUM
)
290 DOUBLEST val
= extract_floating (from
, TYPE_LENGTH(type
));
291 floatformat_from_doublest (&floatformat_ia64_ext
, &val
, to
);
294 error("ia64_register_convert_to_raw called with non floating point register number");
298 ia64_register_virtual_type (int reg
)
300 if (reg
>= IA64_FR0_REGNUM
&& reg
<= IA64_FR127_REGNUM
)
301 return builtin_type_long_double
;
303 return builtin_type_long
;
307 ia64_register_byte (int reg
)
310 (reg
<= IA64_FR0_REGNUM
? 0 : 8 * ((reg
> IA64_FR127_REGNUM
) ? 128 : reg
- IA64_FR0_REGNUM
));
313 /* Read the given register from a sigcontext structure in the
317 read_sigcontext_register (struct frame_info
*frame
, int regnum
)
322 internal_error (__FILE__
, __LINE__
,
323 "read_sigcontext_register: NULL frame");
324 if (!(get_frame_type (frame
) == SIGTRAMP_FRAME
))
325 internal_error (__FILE__
, __LINE__
,
326 "read_sigcontext_register: frame not a signal trampoline");
327 if (SIGCONTEXT_REGISTER_ADDRESS
== 0)
328 internal_error (__FILE__
, __LINE__
,
329 "read_sigcontext_register: SIGCONTEXT_REGISTER_ADDRESS is 0");
331 regaddr
= SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regnum
);
333 return read_memory_integer (regaddr
, REGISTER_RAW_SIZE (regnum
));
335 internal_error (__FILE__
, __LINE__
,
336 "read_sigcontext_register: Register %d not in struct sigcontext", regnum
);
339 /* Extract ``len'' bits from an instruction bundle starting at
343 extract_bit_field (char *bundle
, int from
, int len
)
345 long long result
= 0LL;
347 int from_byte
= from
/ 8;
348 int to_byte
= to
/ 8;
349 unsigned char *b
= (unsigned char *) bundle
;
355 if (from_byte
== to_byte
)
356 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
357 result
= c
>> (from
% 8);
358 lshift
= 8 - (from
% 8);
360 for (i
= from_byte
+1; i
< to_byte
; i
++)
362 result
|= ((long long) b
[i
]) << lshift
;
366 if (from_byte
< to_byte
&& (to
% 8 != 0))
369 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
370 result
|= ((long long) c
) << lshift
;
376 /* Replace the specified bits in an instruction bundle */
379 replace_bit_field (char *bundle
, long long val
, int from
, int len
)
382 int from_byte
= from
/ 8;
383 int to_byte
= to
/ 8;
384 unsigned char *b
= (unsigned char *) bundle
;
387 if (from_byte
== to_byte
)
389 unsigned char left
, right
;
391 left
= (c
>> (to
% 8)) << (to
% 8);
392 right
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
393 c
= (unsigned char) (val
& 0xff);
394 c
= (unsigned char) (c
<< (from
% 8 + 8 - to
% 8)) >> (8 - to
% 8);
402 c
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
403 c
= c
| (val
<< (from
% 8));
405 val
>>= 8 - from
% 8;
407 for (i
= from_byte
+1; i
< to_byte
; i
++)
416 unsigned char cv
= (unsigned char) val
;
418 c
= c
>> (to
% 8) << (to
% 8);
419 c
|= ((unsigned char) (cv
<< (8 - to
% 8))) >> (8 - to
% 8);
425 /* Return the contents of slot N (for N = 0, 1, or 2) in
426 and instruction bundle */
429 slotN_contents (char *bundle
, int slotnum
)
431 return extract_bit_field (bundle
, 5+41*slotnum
, 41);
434 /* Store an instruction in an instruction bundle */
437 replace_slotN_contents (char *bundle
, long long instr
, int slotnum
)
439 replace_bit_field (bundle
, instr
, 5+41*slotnum
, 41);
442 static enum instruction_type template_encoding_table
[32][3] =
444 { M
, I
, I
}, /* 00 */
445 { M
, I
, I
}, /* 01 */
446 { M
, I
, I
}, /* 02 */
447 { M
, I
, I
}, /* 03 */
448 { M
, L
, X
}, /* 04 */
449 { M
, L
, X
}, /* 05 */
450 { undefined
, undefined
, undefined
}, /* 06 */
451 { undefined
, undefined
, undefined
}, /* 07 */
452 { M
, M
, I
}, /* 08 */
453 { M
, M
, I
}, /* 09 */
454 { M
, M
, I
}, /* 0A */
455 { M
, M
, I
}, /* 0B */
456 { M
, F
, I
}, /* 0C */
457 { M
, F
, I
}, /* 0D */
458 { M
, M
, F
}, /* 0E */
459 { M
, M
, F
}, /* 0F */
460 { M
, I
, B
}, /* 10 */
461 { M
, I
, B
}, /* 11 */
462 { M
, B
, B
}, /* 12 */
463 { M
, B
, B
}, /* 13 */
464 { undefined
, undefined
, undefined
}, /* 14 */
465 { undefined
, undefined
, undefined
}, /* 15 */
466 { B
, B
, B
}, /* 16 */
467 { B
, B
, B
}, /* 17 */
468 { M
, M
, B
}, /* 18 */
469 { M
, M
, B
}, /* 19 */
470 { undefined
, undefined
, undefined
}, /* 1A */
471 { undefined
, undefined
, undefined
}, /* 1B */
472 { M
, F
, B
}, /* 1C */
473 { M
, F
, B
}, /* 1D */
474 { undefined
, undefined
, undefined
}, /* 1E */
475 { undefined
, undefined
, undefined
}, /* 1F */
478 /* Fetch and (partially) decode an instruction at ADDR and return the
479 address of the next instruction to fetch. */
482 fetch_instruction (CORE_ADDR addr
, instruction_type
*it
, long long *instr
)
484 char bundle
[BUNDLE_LEN
];
485 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
489 /* Warn about slot numbers greater than 2. We used to generate
490 an error here on the assumption that the user entered an invalid
491 address. But, sometimes GDB itself requests an invalid address.
492 This can (easily) happen when execution stops in a function for
493 which there are no symbols. The prologue scanner will attempt to
494 find the beginning of the function - if the nearest symbol
495 happens to not be aligned on a bundle boundary (16 bytes), the
496 resulting starting address will cause GDB to think that the slot
499 So we warn about it and set the slot number to zero. It is
500 not necessarily a fatal condition, particularly if debugging
501 at the assembly language level. */
504 warning ("Can't fetch instructions for slot numbers greater than 2.\n"
505 "Using slot 0 instead");
511 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
516 *instr
= slotN_contents (bundle
, slotnum
);
517 template = extract_bit_field (bundle
, 0, 5);
518 *it
= template_encoding_table
[(int)template][slotnum
];
520 if (slotnum
== 2 || (slotnum
== 1 && *it
== L
))
523 addr
+= (slotnum
+ 1) * SLOT_MULTIPLIER
;
528 /* There are 5 different break instructions (break.i, break.b,
529 break.m, break.f, and break.x), but they all have the same
530 encoding. (The five bit template in the low five bits of the
531 instruction bundle distinguishes one from another.)
533 The runtime architecture manual specifies that break instructions
534 used for debugging purposes must have the upper two bits of the 21
535 bit immediate set to a 0 and a 1 respectively. A breakpoint
536 instruction encodes the most significant bit of its 21 bit
537 immediate at bit 36 of the 41 bit instruction. The penultimate msb
538 is at bit 25 which leads to the pattern below.
540 Originally, I had this set up to do, e.g, a "break.i 0x80000" But
541 it turns out that 0x80000 was used as the syscall break in the early
542 simulators. So I changed the pattern slightly to do "break.i 0x080001"
543 instead. But that didn't work either (I later found out that this
544 pattern was used by the simulator that I was using.) So I ended up
545 using the pattern seen below. */
548 #define BREAKPOINT 0x00002000040LL
550 #define BREAKPOINT 0x00003333300LL
553 ia64_memory_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
555 char bundle
[BUNDLE_LEN
];
556 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
562 error("Can't insert breakpoint for slot numbers greater than 2.");
566 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
568 /* Check for L type instruction in 2nd slot, if present then
569 bump up the slot number to the 3rd slot */
570 template = extract_bit_field (bundle
, 0, 5);
571 if (slotnum
== 1 && template_encoding_table
[template][1] == L
)
576 instr
= slotN_contents (bundle
, slotnum
);
577 memcpy(contents_cache
, &instr
, sizeof(instr
));
578 replace_slotN_contents (bundle
, BREAKPOINT
, slotnum
);
580 target_write_memory (addr
, bundle
, BUNDLE_LEN
);
586 ia64_memory_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
588 char bundle
[BUNDLE_LEN
];
589 int slotnum
= (addr
& 0x0f) / SLOT_MULTIPLIER
;
596 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
598 /* Check for L type instruction in 2nd slot, if present then
599 bump up the slot number to the 3rd slot */
600 template = extract_bit_field (bundle
, 0, 5);
601 if (slotnum
== 1 && template_encoding_table
[template][1] == L
)
606 memcpy (&instr
, contents_cache
, sizeof instr
);
607 replace_slotN_contents (bundle
, instr
, slotnum
);
609 target_write_memory (addr
, bundle
, BUNDLE_LEN
);
614 /* We don't really want to use this, but remote.c needs to call it in order
615 to figure out if Z-packets are supported or not. Oh, well. */
616 const unsigned char *
617 ia64_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
619 static unsigned char breakpoint
[] =
620 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
621 *lenptr
= sizeof (breakpoint
);
629 ia64_read_pc (ptid_t ptid
)
631 CORE_ADDR psr_value
= read_register_pid (IA64_PSR_REGNUM
, ptid
);
632 CORE_ADDR pc_value
= read_register_pid (IA64_IP_REGNUM
, ptid
);
633 int slot_num
= (psr_value
>> 41) & 3;
635 return pc_value
| (slot_num
* SLOT_MULTIPLIER
);
639 ia64_write_pc (CORE_ADDR new_pc
, ptid_t ptid
)
641 int slot_num
= (int) (new_pc
& 0xf) / SLOT_MULTIPLIER
;
642 CORE_ADDR psr_value
= read_register_pid (IA64_PSR_REGNUM
, ptid
);
643 psr_value
&= ~(3LL << 41);
644 psr_value
|= (CORE_ADDR
)(slot_num
& 0x3) << 41;
648 write_register_pid (IA64_PSR_REGNUM
, psr_value
, ptid
);
649 write_register_pid (IA64_IP_REGNUM
, new_pc
, ptid
);
652 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
654 /* Returns the address of the slot that's NSLOTS slots away from
655 the address ADDR. NSLOTS may be positive or negative. */
657 rse_address_add(CORE_ADDR addr
, int nslots
)
660 int mandatory_nat_slots
= nslots
/ 63;
661 int direction
= nslots
< 0 ? -1 : 1;
663 new_addr
= addr
+ 8 * (nslots
+ mandatory_nat_slots
);
665 if ((new_addr
>> 9) != ((addr
+ 8 * 64 * mandatory_nat_slots
) >> 9))
666 new_addr
+= 8 * direction
;
668 if (IS_NaT_COLLECTION_ADDR(new_addr
))
669 new_addr
+= 8 * direction
;
674 /* The IA-64 frame chain is a bit odd. We won't always have a frame
675 pointer, so we use the SP value as the FP for the purpose of
676 creating a frame. There is sometimes a register (not fixed) which
677 is used as a frame pointer. When this register exists, it is not
678 especially hard to determine which one is being used. It isn't
679 even really hard to compute the frame chain, but it can be
680 computationally expensive. So, instead of making life difficult
681 (and slow), we pick a more convenient representation of the frame
682 chain, knowing that we'll have to make some small adjustments in
683 other places. (E.g, note that read_fp() is actually read_sp() in
684 ia64_gdbarch_init() below.)
686 Okay, so what is the frame chain exactly? It'll be the SP value
687 at the time that the function in question was entered.
689 Note that this *should* actually the frame pointer for the current
690 function! But as I note above, if we were to attempt to find the
691 address of the beginning of the previous frame, we'd waste a lot
692 of cycles for no good reason. So instead, we simply choose to
693 represent the frame chain as the end of the previous frame instead
697 ia64_frame_chain (struct frame_info
*frame
)
699 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
700 return read_sigcontext_register (frame
, sp_regnum
);
701 else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
702 get_frame_base (frame
),
703 get_frame_base (frame
)))
704 return get_frame_base (frame
);
707 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
708 if (get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
])
709 return read_memory_integer (get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
], 8);
711 return (get_frame_base (frame
)
712 + get_frame_extra_info (frame
)->mem_stack_frame_size
);
717 ia64_frame_saved_pc (struct frame_info
*frame
)
719 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
720 return read_sigcontext_register (frame
, pc_regnum
);
721 else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
722 get_frame_base (frame
),
723 get_frame_base (frame
)))
724 return deprecated_read_register_dummy (get_frame_pc (frame
),
725 get_frame_base (frame
), pc_regnum
);
728 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
730 if (get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
])
731 return read_memory_integer (get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
], 8);
732 else if (get_next_frame (frame
)
733 && (get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
))
734 return read_sigcontext_register (get_next_frame (frame
), IA64_BR0_REGNUM
);
735 else /* either frameless, or not far enough along in the prologue... */
736 return ia64_saved_pc_after_call (frame
);
740 /* Limit the number of skipped non-prologue instructions since examining
741 of the prologue is expensive. */
742 static int max_skip_non_prologue_insns
= 10;
744 /* Given PC representing the starting address of a function, and
745 LIM_PC which is the (sloppy) limit to which to scan when looking
746 for a prologue, attempt to further refine this limit by using
747 the line data in the symbol table. If successful, a better guess
748 on where the prologue ends is returned, otherwise the previous
749 value of lim_pc is returned. TRUST_LIMIT is a pointer to a flag
750 which will be set to indicate whether the returned limit may be
751 used with no further scanning in the event that the function is
755 refine_prologue_limit (CORE_ADDR pc
, CORE_ADDR lim_pc
, int *trust_limit
)
757 struct symtab_and_line prologue_sal
;
758 CORE_ADDR start_pc
= pc
;
760 /* Start off not trusting the limit. */
763 prologue_sal
= find_pc_line (pc
, 0);
764 if (prologue_sal
.line
!= 0)
767 CORE_ADDR addr
= prologue_sal
.end
;
769 /* Handle the case in which compiler's optimizer/scheduler
770 has moved instructions into the prologue. We scan ahead
771 in the function looking for address ranges whose corresponding
772 line number is less than or equal to the first one that we
773 found for the function. (It can be less than when the
774 scheduler puts a body instruction before the first prologue
776 for (i
= 2 * max_skip_non_prologue_insns
;
777 i
> 0 && (lim_pc
== 0 || addr
< lim_pc
);
780 struct symtab_and_line sal
;
782 sal
= find_pc_line (addr
, 0);
785 if (sal
.line
<= prologue_sal
.line
786 && sal
.symtab
== prologue_sal
.symtab
)
793 if (lim_pc
== 0 || prologue_sal
.end
< lim_pc
)
795 lim_pc
= prologue_sal
.end
;
796 if (start_pc
== get_pc_function_start (lim_pc
))
803 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
804 || (8 <= (_regnum_) && (_regnum_) <= 11) \
805 || (14 <= (_regnum_) && (_regnum_) <= 31))
806 #define imm9(_instr_) \
807 ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
808 | (((_instr_) & 0x00008000000LL) >> 20) \
809 | (((_instr_) & 0x00000001fc0LL) >> 6))
812 examine_prologue (CORE_ADDR pc
, CORE_ADDR lim_pc
, struct frame_info
*frame
)
815 CORE_ADDR last_prologue_pc
= pc
;
818 int do_fsr_stuff
= 0;
823 int unat_save_reg
= 0;
825 int mem_stack_frame_size
= 0;
827 CORE_ADDR spill_addr
= 0;
832 memset (instores
, 0, sizeof instores
);
833 memset (infpstores
, 0, sizeof infpstores
);
835 if (frame
&& !get_frame_saved_regs (frame
))
837 frame_saved_regs_zalloc (frame
);
843 && get_frame_extra_info (frame
)->after_prologue
!= 0
844 && get_frame_extra_info (frame
)->after_prologue
<= lim_pc
)
845 return get_frame_extra_info (frame
)->after_prologue
;
847 lim_pc
= refine_prologue_limit (pc
, lim_pc
, &trust_limit
);
849 /* Must start with an alloc instruction */
850 next_pc
= fetch_instruction (pc
, &it
, &instr
);
851 if (pc
< lim_pc
&& next_pc
852 && it
== M
&& ((instr
& 0x1ee0000003fLL
) == 0x02c00000000LL
))
855 int sor
= (int) ((instr
& 0x00078000000LL
) >> 27);
856 int sol
= (int) ((instr
& 0x00007f00000LL
) >> 20);
857 int sof
= (int) ((instr
& 0x000000fe000LL
) >> 13);
858 /* Okay, so sor, sol, and sof aren't used right now; but perhaps
859 we could compare against the size given to us via the cfm as
860 either a sanity check or possibly to see if the frame has been
861 changed by a later alloc instruction... */
862 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
864 last_prologue_pc
= next_pc
;
869 pc
= lim_pc
; /* Frameless: We're done early. */
871 last_prologue_pc
= lim_pc
;
874 /* Loop, looking for prologue instructions, keeping track of
875 where preserved registers were spilled. */
878 next_pc
= fetch_instruction (pc
, &it
, &instr
);
882 if ((it
== B
&& ((instr
& 0x1e1f800003f) != 0x04000000000))
883 || ((instr
& 0x3fLL
) != 0LL))
885 /* Exit loop upon hitting a non-nop branch instruction
886 or a predicated instruction. */
889 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00188000000LL
))
892 int b2
= (int) ((instr
& 0x0000000e000LL
) >> 13);
893 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
894 int qp
= (int) (instr
& 0x0000000003f);
896 if (qp
== 0 && b2
== 0 && rN
>= 32 && ret_reg
== 0)
899 last_prologue_pc
= next_pc
;
902 else if ((it
== I
|| it
== M
)
903 && ((instr
& 0x1ee00000000LL
) == 0x10800000000LL
))
905 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
906 int imm
= (int) ((((instr
& 0x01000000000LL
) ? -1 : 0) << 13)
907 | ((instr
& 0x001f8000000LL
) >> 20)
908 | ((instr
& 0x000000fe000LL
) >> 13));
909 int rM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
910 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
911 int qp
= (int) (instr
& 0x0000000003fLL
);
913 if (qp
== 0 && rN
>= 32 && imm
== 0 && rM
== 12 && fp_reg
== 0)
917 last_prologue_pc
= next_pc
;
919 else if (qp
== 0 && rN
== 12 && rM
== 12)
921 /* adds r12, -mem_stack_frame_size, r12 */
922 mem_stack_frame_size
-= imm
;
923 last_prologue_pc
= next_pc
;
925 else if (qp
== 0 && rN
== 2
926 && ((rM
== fp_reg
&& fp_reg
!= 0) || rM
== 12))
928 /* adds r2, spilloffset, rFramePointer
930 adds r2, spilloffset, r12
932 Get ready for stf.spill or st8.spill instructions.
933 The address to start spilling at is loaded into r2.
934 FIXME: Why r2? That's what gcc currently uses; it
935 could well be different for other compilers. */
937 /* Hmm... whether or not this will work will depend on
938 where the pc is. If it's still early in the prologue
939 this'll be wrong. FIXME */
940 spill_addr
= (frame
? get_frame_base (frame
) : 0)
941 + (rM
== 12 ? 0 : mem_stack_frame_size
)
944 last_prologue_pc
= next_pc
;
948 && ( ((instr
& 0x1efc0000000LL
) == 0x0eec0000000LL
)
949 || ((instr
& 0x1ffc8000000LL
) == 0x0cec0000000LL
) ))
951 /* stf.spill [rN] = fM, imm9
953 stf.spill [rN] = fM */
955 int imm
= imm9(instr
);
956 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
957 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
958 int qp
= (int) (instr
& 0x0000000003fLL
);
959 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
960 && ((2 <= fM
&& fM
<= 5) || (16 <= fM
&& fM
<= 31)))
963 get_frame_saved_regs (frame
)[IA64_FR0_REGNUM
+ fM
] = spill_addr
;
965 if ((instr
& 0x1efc0000000) == 0x0eec0000000)
968 spill_addr
= 0; /* last one; must be done */
969 last_prologue_pc
= next_pc
;
972 else if ((it
== M
&& ((instr
& 0x1eff8000000LL
) == 0x02110000000LL
))
973 || (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00050000000LL
)) )
979 int arM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
980 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
981 int qp
= (int) (instr
& 0x0000000003fLL
);
982 if (qp
== 0 && isScratch (rN
) && arM
== 36 /* ar.unat */)
984 /* We have something like "mov.m r3 = ar.unat". Remember the
985 r3 (or whatever) and watch for a store of this register... */
987 last_prologue_pc
= next_pc
;
990 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00198000000LL
))
993 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
994 int qp
= (int) (instr
& 0x0000000003fLL
);
995 if (qp
== 0 && isScratch (rN
))
998 last_prologue_pc
= next_pc
;
1002 && ( ((instr
& 0x1ffc8000000LL
) == 0x08cc0000000LL
)
1003 || ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)))
1007 st8 [rN] = rM, imm9 */
1008 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1009 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1010 int qp
= (int) (instr
& 0x0000000003fLL
);
1011 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
1012 && (rM
== unat_save_reg
|| rM
== pr_save_reg
))
1014 /* We've found a spill of either the UNAT register or the PR
1015 register. (Well, not exactly; what we've actually found is
1016 a spill of the register that UNAT or PR was moved to).
1017 Record that fact and move on... */
1018 if (rM
== unat_save_reg
)
1020 /* Track UNAT register */
1022 get_frame_saved_regs (frame
)[IA64_UNAT_REGNUM
] = spill_addr
;
1027 /* Track PR register */
1029 get_frame_saved_regs (frame
)[IA64_PR_REGNUM
] = spill_addr
;
1032 if ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)
1033 /* st8 [rN] = rM, imm9 */
1034 spill_addr
+= imm9(instr
);
1036 spill_addr
= 0; /* must be done spilling */
1037 last_prologue_pc
= next_pc
;
1039 else if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1041 /* Allow up to one store of each input register. */
1042 instores
[rM
-32] = 1;
1043 last_prologue_pc
= next_pc
;
1046 else if (it
== M
&& ((instr
& 0x1ff08000000LL
) == 0x08c00000000LL
))
1053 Note that the st8 case is handled in the clause above.
1055 Advance over stores of input registers. One store per input
1056 register is permitted. */
1057 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1058 int qp
= (int) (instr
& 0x0000000003fLL
);
1059 if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1061 instores
[rM
-32] = 1;
1062 last_prologue_pc
= next_pc
;
1065 else if (it
== M
&& ((instr
& 0x1ff88000000LL
) == 0x0cc80000000LL
))
1072 Advance over stores of floating point input registers. Again
1073 one store per register is permitted */
1074 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1075 int qp
= (int) (instr
& 0x0000000003fLL
);
1076 if (qp
== 0 && 8 <= fM
&& fM
< 16 && !infpstores
[fM
- 8])
1078 infpstores
[fM
-8] = 1;
1079 last_prologue_pc
= next_pc
;
1083 && ( ((instr
& 0x1ffc8000000LL
) == 0x08ec0000000LL
)
1084 || ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)))
1086 /* st8.spill [rN] = rM
1088 st8.spill [rN] = rM, imm9 */
1089 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1090 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1091 int qp
= (int) (instr
& 0x0000000003fLL
);
1092 if (qp
== 0 && rN
== spill_reg
&& 4 <= rM
&& rM
<= 7)
1094 /* We've found a spill of one of the preserved general purpose
1095 regs. Record the spill address and advance the spill
1096 register if appropriate. */
1098 get_frame_saved_regs (frame
)[IA64_GR0_REGNUM
+ rM
] = spill_addr
;
1099 if ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)
1100 /* st8.spill [rN] = rM, imm9 */
1101 spill_addr
+= imm9(instr
);
1103 spill_addr
= 0; /* Done spilling */
1104 last_prologue_pc
= next_pc
;
1116 /* Extract the size of the rotating portion of the stack
1117 frame and the register rename base from the current
1119 sor
= ((get_frame_extra_info (frame
)->cfm
>> 14) & 0xf) * 8;
1120 rrb_gr
= (get_frame_extra_info (frame
)->cfm
>> 18) & 0x7f;
1122 for (i
= 0, addr
= get_frame_extra_info (frame
)->bsp
;
1123 i
< get_frame_extra_info (frame
)->sof
;
1126 if (IS_NaT_COLLECTION_ADDR (addr
))
1131 get_frame_saved_regs (frame
)[IA64_GR32_REGNUM
+ ((i
+ (sor
- rrb_gr
)) % sor
)]
1134 get_frame_saved_regs (frame
)[IA64_GR32_REGNUM
+ i
] = addr
;
1136 if (i
+32 == cfm_reg
)
1137 get_frame_saved_regs (frame
)[IA64_CFM_REGNUM
] = addr
;
1138 if (i
+32 == ret_reg
)
1139 get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
] = addr
;
1141 get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
] = addr
;
1145 if (frame
&& get_frame_extra_info (frame
))
1147 get_frame_extra_info (frame
)->after_prologue
= last_prologue_pc
;
1148 get_frame_extra_info (frame
)->mem_stack_frame_size
= mem_stack_frame_size
;
1149 get_frame_extra_info (frame
)->fp_reg
= fp_reg
;
1152 return last_prologue_pc
;
1156 ia64_skip_prologue (CORE_ADDR pc
)
1158 return examine_prologue (pc
, pc
+1024, 0);
1162 ia64_frame_init_saved_regs (struct frame_info
*frame
)
1164 if (get_frame_saved_regs (frame
))
1167 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
) && SIGCONTEXT_REGISTER_ADDRESS
)
1171 frame_saved_regs_zalloc (frame
);
1173 get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
] =
1174 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_IP_REGNUM
);
1175 get_frame_saved_regs (frame
)[IA64_CFM_REGNUM
] =
1176 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_CFM_REGNUM
);
1177 get_frame_saved_regs (frame
)[IA64_PSR_REGNUM
] =
1178 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_PSR_REGNUM
);
1180 get_frame_saved_regs (frame
)[IA64_BSP_REGNUM
] =
1181 SIGCONTEXT_REGISTER_ADDRESS (frame
->frame
, IA64_BSP_REGNUM
);
1183 get_frame_saved_regs (frame
)[IA64_RNAT_REGNUM
] =
1184 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_RNAT_REGNUM
);
1185 get_frame_saved_regs (frame
)[IA64_CCV_REGNUM
] =
1186 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_CCV_REGNUM
);
1187 get_frame_saved_regs (frame
)[IA64_UNAT_REGNUM
] =
1188 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_UNAT_REGNUM
);
1189 get_frame_saved_regs (frame
)[IA64_FPSR_REGNUM
] =
1190 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_FPSR_REGNUM
);
1191 get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
] =
1192 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_PFS_REGNUM
);
1193 get_frame_saved_regs (frame
)[IA64_LC_REGNUM
] =
1194 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_LC_REGNUM
);
1195 for (regno
= IA64_GR1_REGNUM
; regno
<= IA64_GR31_REGNUM
; regno
++)
1196 if (regno
!= sp_regnum
)
1197 get_frame_saved_regs (frame
)[regno
] =
1198 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1199 for (regno
= IA64_BR0_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
1200 get_frame_saved_regs (frame
)[regno
] =
1201 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1202 for (regno
= IA64_FR2_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
1203 get_frame_saved_regs (frame
)[regno
] =
1204 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1208 CORE_ADDR func_start
;
1210 func_start
= get_pc_function_start (get_frame_pc (frame
));
1211 examine_prologue (func_start
, get_frame_pc (frame
), frame
);
1216 ia64_get_saved_register (char *raw_buffer
,
1219 struct frame_info
*frame
,
1221 enum lval_type
*lval
)
1225 if (!target_has_registers
)
1226 error ("No registers.");
1228 if (optimized
!= NULL
)
1237 is_dummy_frame
= DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
1238 get_frame_base (frame
),
1239 get_frame_base (frame
));
1241 if (regnum
== SP_REGNUM
&& get_next_frame (frame
))
1243 /* Handle SP values for all frames but the topmost. */
1244 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1245 get_frame_base (frame
));
1247 else if (regnum
== IA64_BSP_REGNUM
)
1249 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1250 get_frame_extra_info (frame
)->bsp
);
1252 else if (regnum
== IA64_VFP_REGNUM
)
1254 /* If the function in question uses an automatic register (r32-r127)
1255 for the frame pointer, it'll be found by ia64_find_saved_register()
1256 above. If the function lacks one of these frame pointers, we can
1257 still provide a value since we know the size of the frame */
1258 CORE_ADDR vfp
= (get_frame_base (frame
)
1259 + get_frame_extra_info (frame
)->mem_stack_frame_size
);
1260 store_address (raw_buffer
, REGISTER_RAW_SIZE (IA64_VFP_REGNUM
), vfp
);
1262 else if (IA64_PR0_REGNUM
<= regnum
&& regnum
<= IA64_PR63_REGNUM
)
1264 char *pr_raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
1266 enum lval_type pr_lval
;
1269 ia64_get_saved_register (pr_raw_buffer
, &pr_optim
, &pr_addr
,
1270 frame
, IA64_PR_REGNUM
, &pr_lval
);
1271 if (IA64_PR16_REGNUM
<= regnum
&& regnum
<= IA64_PR63_REGNUM
)
1273 /* Fetch predicate register rename base from current frame
1274 marker for this frame. */
1275 int rrb_pr
= (get_frame_extra_info (frame
)->cfm
>> 32) & 0x3f;
1277 /* Adjust the register number to account for register rotation. */
1278 regnum
= IA64_PR16_REGNUM
1279 + ((regnum
- IA64_PR16_REGNUM
) + rrb_pr
) % 48;
1281 prN_val
= extract_bit_field ((unsigned char *) pr_raw_buffer
,
1282 regnum
- IA64_PR0_REGNUM
, 1);
1283 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), prN_val
);
1285 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT31_REGNUM
)
1287 char *unat_raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
1289 enum lval_type unat_lval
;
1290 CORE_ADDR unat_addr
;
1292 ia64_get_saved_register (unat_raw_buffer
, &unat_optim
, &unat_addr
,
1293 frame
, IA64_UNAT_REGNUM
, &unat_lval
);
1294 unatN_val
= extract_bit_field ((unsigned char *) unat_raw_buffer
,
1295 regnum
- IA64_NAT0_REGNUM
, 1);
1296 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1299 else if (IA64_NAT32_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
1302 /* Find address of general register corresponding to nat bit we're
1304 CORE_ADDR gr_addr
= 0;
1306 if (!is_dummy_frame
)
1308 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1309 gr_addr
= get_frame_saved_regs (frame
)[ regnum
- IA64_NAT0_REGNUM
1314 /* Compute address of nat collection bits */
1315 CORE_ADDR nat_addr
= gr_addr
| 0x1f8;
1316 CORE_ADDR bsp
= read_register (IA64_BSP_REGNUM
);
1317 CORE_ADDR nat_collection
;
1319 /* If our nat collection address is bigger than bsp, we have to get
1320 the nat collection from rnat. Otherwise, we fetch the nat
1321 collection from the computed address. */
1322 if (nat_addr
>= bsp
)
1323 nat_collection
= read_register (IA64_RNAT_REGNUM
);
1325 nat_collection
= read_memory_integer (nat_addr
, 8);
1326 nat_bit
= (gr_addr
>> 3) & 0x3f;
1327 natval
= (nat_collection
>> nat_bit
) & 1;
1329 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), natval
);
1331 else if (regnum
== IA64_IP_REGNUM
)
1334 if (get_next_frame (frame
))
1336 /* FIXME: Set *addrp, *lval when possible. */
1337 pc
= ia64_frame_saved_pc (get_next_frame (frame
));
1343 store_address (raw_buffer
, REGISTER_RAW_SIZE (IA64_IP_REGNUM
), pc
);
1345 else if (IA64_GR32_REGNUM
<= regnum
&& regnum
<= IA64_GR127_REGNUM
)
1348 if (!is_dummy_frame
)
1350 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1351 addr
= get_frame_saved_regs (frame
)[regnum
];
1357 *lval
= lval_memory
;
1360 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1364 /* r32 - r127 must be fetchable via memory. If they aren't,
1365 then the register is unavailable */
1366 memset (raw_buffer
, 0, REGISTER_RAW_SIZE (regnum
));
1371 if (IA64_FR32_REGNUM
<= regnum
&& regnum
<= IA64_FR127_REGNUM
)
1373 /* Fetch floating point register rename base from current
1374 frame marker for this frame. */
1375 int rrb_fr
= (get_frame_extra_info (frame
)->cfm
>> 25) & 0x7f;
1377 /* Adjust the floating point register number to account for
1378 register rotation. */
1379 regnum
= IA64_FR32_REGNUM
1380 + ((regnum
- IA64_FR32_REGNUM
) + rrb_fr
) % 96;
1383 deprecated_generic_get_saved_register (raw_buffer
, optimized
, addrp
,
1384 frame
, regnum
, lval
);
1388 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1389 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1390 and TYPE is the type (which is known to be struct, union or array). */
1392 ia64_use_struct_convention (int gcc_p
, struct type
*type
)
1394 struct type
*float_elt_type
;
1396 /* HFAs are structures (or arrays) consisting entirely of floating
1397 point values of the same length. Up to 8 of these are returned
1398 in registers. Don't use the struct convention when this is the
1400 float_elt_type
= is_float_or_hfa_type (type
);
1401 if (float_elt_type
!= NULL
1402 && TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
) <= 8)
1405 /* Other structs of length 32 or less are returned in r8-r11.
1406 Don't use the struct convention for those either. */
1407 return TYPE_LENGTH (type
) > 32;
1411 ia64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
1413 struct type
*float_elt_type
;
1415 float_elt_type
= is_float_or_hfa_type (type
);
1416 if (float_elt_type
!= NULL
)
1419 int regnum
= IA64_FR8_REGNUM
;
1420 int n
= TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
);
1424 ia64_register_convert_to_virtual (regnum
, float_elt_type
,
1425 ®buf
[REGISTER_BYTE (regnum
)], valbuf
+ offset
);
1426 offset
+= TYPE_LENGTH (float_elt_type
);
1431 memcpy (valbuf
, ®buf
[REGISTER_BYTE (IA64_GR8_REGNUM
)],
1432 TYPE_LENGTH (type
));
1435 /* FIXME: Turn this into a stack of some sort. Unfortunately, something
1436 like this is necessary though since the IA-64 calling conventions specify
1437 that r8 is not preserved. */
1438 static CORE_ADDR struct_return_address
;
1441 ia64_extract_struct_value_address (char *regbuf
)
1443 /* FIXME: See above. */
1444 return struct_return_address
;
1448 ia64_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1450 /* FIXME: See above. */
1451 /* Note that most of the work was done in ia64_push_arguments() */
1452 struct_return_address
= addr
;
1456 ia64_frameless_function_invocation (struct frame_info
*frame
)
1458 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1459 return (get_frame_extra_info (frame
)->mem_stack_frame_size
== 0);
1463 ia64_saved_pc_after_call (struct frame_info
*frame
)
1465 return read_register (IA64_BR0_REGNUM
);
1469 ia64_frame_args_address (struct frame_info
*frame
)
1471 /* frame->frame points at the SP for this frame; But we want the start
1472 of the frame, not the end. Calling frame chain will get his for us. */
1473 return ia64_frame_chain (frame
);
1477 ia64_frame_locals_address (struct frame_info
*frame
)
1479 /* frame->frame points at the SP for this frame; But we want the start
1480 of the frame, not the end. Calling frame chain will get his for us. */
1481 return ia64_frame_chain (frame
);
1485 ia64_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
1488 int next_frame_is_call_dummy
= ((get_next_frame (frame
) != NULL
)
1489 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frame
)),
1490 get_frame_base (get_next_frame (frame
)),
1491 get_frame_base (get_next_frame (frame
))));
1493 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
1495 if (get_next_frame (frame
) == 0)
1497 bsp
= read_register (IA64_BSP_REGNUM
);
1498 cfm
= read_register (IA64_CFM_REGNUM
);
1501 else if ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
))
1503 bsp
= read_sigcontext_register (get_next_frame (frame
), IA64_BSP_REGNUM
);
1504 cfm
= read_sigcontext_register (get_next_frame (frame
), IA64_CFM_REGNUM
);
1506 else if (next_frame_is_call_dummy
)
1508 bsp
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame
)),
1509 get_frame_base (get_next_frame (frame
)),
1511 cfm
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame
)),
1512 get_frame_base (get_next_frame (frame
)),
1517 struct frame_info
*frn
= get_next_frame (frame
);
1519 DEPRECATED_FRAME_INIT_SAVED_REGS (frn
);
1521 if (get_frame_saved_regs (frn
)[IA64_CFM_REGNUM
] != 0)
1522 cfm
= read_memory_integer (get_frame_saved_regs (frn
)[IA64_CFM_REGNUM
], 8);
1523 else if (get_next_frame (frn
) && (get_frame_type (get_next_frame (frn
)) == SIGTRAMP_FRAME
))
1524 cfm
= read_sigcontext_register (get_next_frame (frn
), IA64_PFS_REGNUM
);
1525 else if (get_next_frame (frn
)
1526 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frn
)),
1527 get_frame_base (get_next_frame (frn
)),
1528 get_frame_base (get_next_frame (frn
))))
1529 cfm
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frn
)),
1530 get_frame_base (get_next_frame (frn
)),
1533 cfm
= read_register (IA64_PFS_REGNUM
);
1535 bsp
= get_frame_extra_info (frn
)->bsp
;
1537 get_frame_extra_info (frame
)->cfm
= cfm
;
1538 get_frame_extra_info (frame
)->sof
= cfm
& 0x7f;
1539 get_frame_extra_info (frame
)->sol
= (cfm
>> 7) & 0x7f;
1540 if (get_next_frame (frame
) == 0
1541 || (get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
)
1542 || next_frame_is_call_dummy
)
1543 get_frame_extra_info (frame
)->bsp
=
1544 rse_address_add (bsp
, -get_frame_extra_info (frame
)->sof
);
1546 get_frame_extra_info (frame
)->bsp
=
1547 rse_address_add (bsp
, -get_frame_extra_info (frame
)->sol
);
1549 get_frame_extra_info (frame
)->after_prologue
= 0;
1550 get_frame_extra_info (frame
)->mem_stack_frame_size
= -1; /* Not yet determined */
1551 get_frame_extra_info (frame
)->fp_reg
= 0;
1555 is_float_or_hfa_type_recurse (struct type
*t
, struct type
**etp
)
1557 switch (TYPE_CODE (t
))
1561 return TYPE_LENGTH (*etp
) == TYPE_LENGTH (t
);
1568 case TYPE_CODE_ARRAY
:
1570 is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t
)),
1573 case TYPE_CODE_STRUCT
:
1577 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
1578 if (!is_float_or_hfa_type_recurse
1579 (check_typedef (TYPE_FIELD_TYPE (t
, i
)), etp
))
1590 /* Determine if the given type is one of the floating point types or
1591 and HFA (which is a struct, array, or combination thereof whose
1592 bottom-most elements are all of the same floating point type.) */
1594 static struct type
*
1595 is_float_or_hfa_type (struct type
*t
)
1597 struct type
*et
= 0;
1599 return is_float_or_hfa_type_recurse (t
, &et
) ? et
: 0;
1603 /* Return 1 if the alignment of T is such that the next even slot
1604 should be used. Return 0, if the next available slot should
1605 be used. (See section 8.5.1 of the IA-64 Software Conventions
1606 and Runtime manual.) */
1609 slot_alignment_is_next_even (struct type
*t
)
1611 switch (TYPE_CODE (t
))
1615 if (TYPE_LENGTH (t
) > 8)
1619 case TYPE_CODE_ARRAY
:
1621 slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t
)));
1622 case TYPE_CODE_STRUCT
:
1626 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
1627 if (slot_alignment_is_next_even
1628 (check_typedef (TYPE_FIELD_TYPE (t
, i
))))
1637 /* Attempt to find (and return) the global pointer for the given
1640 This is a rather nasty bit of code searchs for the .dynamic section
1641 in the objfile corresponding to the pc of the function we're trying
1642 to call. Once it finds the addresses at which the .dynamic section
1643 lives in the child process, it scans the Elf64_Dyn entries for a
1644 DT_PLTGOT tag. If it finds one of these, the corresponding
1645 d_un.d_ptr value is the global pointer. */
1648 generic_elf_find_global_pointer (CORE_ADDR faddr
)
1650 struct obj_section
*faddr_sect
;
1652 faddr_sect
= find_pc_section (faddr
);
1653 if (faddr_sect
!= NULL
)
1655 struct obj_section
*osect
;
1657 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
1659 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
1663 if (osect
< faddr_sect
->objfile
->sections_end
)
1668 while (addr
< osect
->endaddr
)
1674 status
= target_read_memory (addr
, buf
, sizeof (buf
));
1677 tag
= extract_signed_integer (buf
, sizeof (buf
));
1679 if (tag
== DT_PLTGOT
)
1681 CORE_ADDR global_pointer
;
1683 status
= target_read_memory (addr
+ 8, buf
, sizeof (buf
));
1686 global_pointer
= extract_address (buf
, sizeof (buf
));
1689 return global_pointer
;
1702 /* Given a function's address, attempt to find (and return) the
1703 corresponding (canonical) function descriptor. Return 0 if
1706 find_extant_func_descr (CORE_ADDR faddr
)
1708 struct obj_section
*faddr_sect
;
1710 /* Return early if faddr is already a function descriptor */
1711 faddr_sect
= find_pc_section (faddr
);
1712 if (faddr_sect
&& strcmp (faddr_sect
->the_bfd_section
->name
, ".opd") == 0)
1715 if (faddr_sect
!= NULL
)
1717 struct obj_section
*osect
;
1718 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
1720 if (strcmp (osect
->the_bfd_section
->name
, ".opd") == 0)
1724 if (osect
< faddr_sect
->objfile
->sections_end
)
1729 while (addr
< osect
->endaddr
)
1735 status
= target_read_memory (addr
, buf
, sizeof (buf
));
1738 faddr2
= extract_signed_integer (buf
, sizeof (buf
));
1740 if (faddr
== faddr2
)
1750 /* Attempt to find a function descriptor corresponding to the
1751 given address. If none is found, construct one on the
1752 stack using the address at fdaptr */
1755 find_func_descr (CORE_ADDR faddr
, CORE_ADDR
*fdaptr
)
1759 fdesc
= find_extant_func_descr (faddr
);
1763 CORE_ADDR global_pointer
;
1769 global_pointer
= FIND_GLOBAL_POINTER (faddr
);
1771 if (global_pointer
== 0)
1772 global_pointer
= read_register (IA64_GR1_REGNUM
);
1774 store_address (buf
, 8, faddr
);
1775 store_address (buf
+ 8, 8, global_pointer
);
1777 write_memory (fdesc
, buf
, 16);
1784 ia64_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1785 int struct_return
, CORE_ADDR struct_addr
)
1791 int nslots
, rseslots
, memslots
, slotnum
, nfuncargs
;
1793 CORE_ADDR bsp
, cfm
, pfs
, new_bsp
, funcdescaddr
;
1797 /* Count the number of slots needed for the arguments */
1798 for (argno
= 0; argno
< nargs
; argno
++)
1801 type
= check_typedef (VALUE_TYPE (arg
));
1802 len
= TYPE_LENGTH (type
);
1804 if ((nslots
& 1) && slot_alignment_is_next_even (type
))
1807 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1810 nslots
+= (len
+ 7) / 8;
1813 /* Divvy up the slots between the RSE and the memory stack */
1814 rseslots
= (nslots
> 8) ? 8 : nslots
;
1815 memslots
= nslots
- rseslots
;
1817 /* Allocate a new RSE frame */
1818 cfm
= read_register (IA64_CFM_REGNUM
);
1820 bsp
= read_register (IA64_BSP_REGNUM
);
1821 bsp
= rse_address_add (bsp
, cfm
& 0x7f);
1822 new_bsp
= rse_address_add (bsp
, rseslots
);
1823 write_register (IA64_BSP_REGNUM
, new_bsp
);
1825 pfs
= read_register (IA64_PFS_REGNUM
);
1826 pfs
&= 0xc000000000000000LL
;
1827 pfs
|= (cfm
& 0xffffffffffffLL
);
1828 write_register (IA64_PFS_REGNUM
, pfs
);
1830 cfm
&= 0xc000000000000000LL
;
1832 write_register (IA64_CFM_REGNUM
, cfm
);
1834 /* We will attempt to find function descriptors in the .opd segment,
1835 but if we can't we'll construct them ourselves. That being the
1836 case, we'll need to reserve space on the stack for them. */
1837 funcdescaddr
= sp
- nfuncargs
* 16;
1838 funcdescaddr
&= ~0xfLL
;
1840 /* Adjust the stack pointer to it's new value. The calling conventions
1841 require us to have 16 bytes of scratch, plus whatever space is
1842 necessary for the memory slots and our function descriptors */
1843 sp
= sp
- 16 - (memslots
+ nfuncargs
) * 8;
1844 sp
&= ~0xfLL
; /* Maintain 16 byte alignment */
1846 /* Place the arguments where they belong. The arguments will be
1847 either placed in the RSE backing store or on the memory stack.
1848 In addition, floating point arguments or HFAs are placed in
1849 floating point registers. */
1851 floatreg
= IA64_FR8_REGNUM
;
1852 for (argno
= 0; argno
< nargs
; argno
++)
1854 struct type
*float_elt_type
;
1857 type
= check_typedef (VALUE_TYPE (arg
));
1858 len
= TYPE_LENGTH (type
);
1860 /* Special handling for function parameters */
1862 && TYPE_CODE (type
) == TYPE_CODE_PTR
1863 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1867 store_address (val_buf
, 8,
1868 find_func_descr (extract_address (VALUE_CONTENTS (arg
), 8),
1870 if (slotnum
< rseslots
)
1871 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
1873 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
1880 /* Skip odd slot if necessary... */
1881 if ((slotnum
& 1) && slot_alignment_is_next_even (type
))
1889 memset (val_buf
, 0, 8);
1890 memcpy (val_buf
, VALUE_CONTENTS (arg
) + argoffset
, (len
> 8) ? 8 : len
);
1892 if (slotnum
< rseslots
)
1893 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
1895 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
1902 /* Handle floating point types (including HFAs) */
1903 float_elt_type
= is_float_or_hfa_type (type
);
1904 if (float_elt_type
!= NULL
)
1907 len
= TYPE_LENGTH (type
);
1908 while (len
> 0 && floatreg
< IA64_FR16_REGNUM
)
1910 ia64_register_convert_to_raw (
1913 VALUE_CONTENTS (arg
) + argoffset
,
1914 &deprecated_registers
[REGISTER_BYTE (floatreg
)]);
1916 argoffset
+= TYPE_LENGTH (float_elt_type
);
1917 len
-= TYPE_LENGTH (float_elt_type
);
1922 /* Store the struct return value in r8 if necessary. */
1925 store_address (&deprecated_registers
[REGISTER_BYTE (IA64_GR8_REGNUM
)],
1926 REGISTER_RAW_SIZE (IA64_GR8_REGNUM
),
1930 /* Sync gdb's idea of what the registers are with the target. */
1931 target_store_registers (-1);
1933 /* FIXME: This doesn't belong here! Instead, SAVE_DUMMY_FRAME_TOS needs
1934 to be defined to call generic_save_dummy_frame_tos(). But at the
1935 time of this writing, SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so
1936 I chose to put this call here instead of using the old mechanisms.
1937 Once SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do is add the
1940 set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1942 to ia64_gdbarch_init() and remove the line below. */
1943 generic_save_dummy_frame_tos (sp
);
1949 ia64_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1951 CORE_ADDR global_pointer
= FIND_GLOBAL_POINTER (pc
);
1953 if (global_pointer
!= 0)
1954 write_register (IA64_GR1_REGNUM
, global_pointer
);
1956 write_register (IA64_BR0_REGNUM
, CALL_DUMMY_ADDRESS ());
1961 ia64_store_return_value (struct type
*type
, char *valbuf
)
1963 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1965 ia64_register_convert_to_raw (type
, IA64_FR8_REGNUM
, valbuf
,
1966 &deprecated_registers
[REGISTER_BYTE (IA64_FR8_REGNUM
)]);
1967 target_store_registers (IA64_FR8_REGNUM
);
1970 deprecated_write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM
),
1971 valbuf
, TYPE_LENGTH (type
));
1975 ia64_pop_frame (void)
1977 generic_pop_current_frame (ia64_pop_frame_regular
);
1981 ia64_pop_frame_regular (struct frame_info
*frame
)
1984 CORE_ADDR bsp
, cfm
, pfs
;
1986 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1988 for (regno
= 0; regno
< ia64_num_regs
; regno
++)
1990 if (get_frame_saved_regs (frame
)[regno
]
1991 && (!(IA64_GR32_REGNUM
<= regno
&& regno
<= IA64_GR127_REGNUM
))
1992 && regno
!= pc_regnum
1993 && regno
!= sp_regnum
1994 && regno
!= IA64_PFS_REGNUM
1995 && regno
!= IA64_CFM_REGNUM
1996 && regno
!= IA64_BSP_REGNUM
1997 && regno
!= IA64_BSPSTORE_REGNUM
)
1999 write_register (regno
,
2000 read_memory_integer (get_frame_saved_regs (frame
)[regno
],
2001 REGISTER_RAW_SIZE (regno
)));
2005 write_register (sp_regnum
, DEPRECATED_FRAME_CHAIN (frame
));
2006 write_pc (DEPRECATED_FRAME_SAVED_PC (frame
));
2008 cfm
= read_register (IA64_CFM_REGNUM
);
2010 if (get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
])
2012 pfs
= read_memory_integer (get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
],
2013 REGISTER_RAW_SIZE (IA64_PFS_REGNUM
));
2016 pfs
= read_register (IA64_PFS_REGNUM
);
2018 /* Compute the new bsp by *adding* the difference between the
2019 size of the frame and the size of the locals (both wrt the
2020 frame that we're going back to). This seems kind of strange,
2021 especially since it seems like we ought to be subtracting the
2022 size of the locals... and we should; but the Linux kernel
2023 wants bsp to be set at the end of all used registers. It's
2024 likely that this code will need to be revised to accomodate
2025 other operating systems. */
2026 bsp
= rse_address_add (get_frame_extra_info (frame
)->bsp
,
2027 (pfs
& 0x7f) - ((pfs
>> 7) & 0x7f));
2028 write_register (IA64_BSP_REGNUM
, bsp
);
2030 /* FIXME: What becomes of the epilog count in the PFS? */
2031 cfm
= (cfm
& ~0xffffffffffffLL
) | (pfs
& 0xffffffffffffLL
);
2032 write_register (IA64_CFM_REGNUM
, cfm
);
2034 flush_cached_frames ();
2038 ia64_remote_translate_xfer_address (CORE_ADDR memaddr
, int nr_bytes
,
2039 CORE_ADDR
*targ_addr
, int *targ_len
)
2041 *targ_addr
= memaddr
;
2042 *targ_len
= nr_bytes
;
2046 process_note_abi_tag_sections (bfd
*abfd
, asection
*sect
, void *obj
)
2048 int *os_ident_ptr
= obj
;
2050 unsigned int sectsize
;
2052 name
= bfd_get_section_name (abfd
, sect
);
2053 sectsize
= bfd_section_size (abfd
, sect
);
2054 if (strcmp (name
, ".note.ABI-tag") == 0 && sectsize
> 0)
2056 unsigned int name_length
, data_length
, note_type
;
2057 char *note
= alloca (sectsize
);
2059 bfd_get_section_contents (abfd
, sect
, note
,
2060 (file_ptr
) 0, (bfd_size_type
) sectsize
);
2062 name_length
= bfd_h_get_32 (abfd
, note
);
2063 data_length
= bfd_h_get_32 (abfd
, note
+ 4);
2064 note_type
= bfd_h_get_32 (abfd
, note
+ 8);
2066 if (name_length
== 4 && data_length
== 16 && note_type
== 1
2067 && strcmp (note
+ 12, "GNU") == 0)
2069 int os_number
= bfd_h_get_32 (abfd
, note
+ 16);
2071 /* The case numbers are from abi-tags in glibc */
2075 *os_ident_ptr
= ELFOSABI_LINUX
;
2078 *os_ident_ptr
= ELFOSABI_HURD
;
2081 *os_ident_ptr
= ELFOSABI_SOLARIS
;
2084 internal_error (__FILE__
, __LINE__
,
2085 "process_note_abi_sections: unknown OS number %d", os_number
);
2092 static struct gdbarch
*
2093 ia64_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2095 struct gdbarch
*gdbarch
;
2096 struct gdbarch_tdep
*tdep
;
2099 if (info
.abfd
!= NULL
2100 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
2102 os_ident
= elf_elfheader (info
.abfd
)->e_ident
[EI_OSABI
];
2104 /* If os_ident is 0, it is not necessarily the case that we're
2105 on a SYSV system. (ELFOSABI_NONE is defined to be 0.)
2106 GNU/Linux uses a note section to record OS/ABI info, but
2107 leaves e_ident[EI_OSABI] zero. So we have to check for note
2111 bfd_map_over_sections (info
.abfd
,
2112 process_note_abi_tag_sections
,
2119 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2121 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
2123 tdep
= gdbarch_tdep (arches
->gdbarch
);
2124 if (tdep
&&tdep
->os_ident
== os_ident
)
2125 return arches
->gdbarch
;
2128 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
2129 gdbarch
= gdbarch_alloc (&info
, tdep
);
2130 tdep
->os_ident
= os_ident
;
2132 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2133 ready to unwind the PC first (see frame.c:get_prev_frame()). */
2134 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
2136 /* Set the method of obtaining the sigcontext addresses at which
2137 registers are saved. The method of checking to see if
2138 native_find_global_pointer is nonzero to indicate that we're
2139 on AIX is kind of hokey, but I can't think of a better way
2141 if (os_ident
== ELFOSABI_LINUX
)
2142 tdep
->sigcontext_register_address
= ia64_linux_sigcontext_register_address
;
2143 else if (native_find_global_pointer
!= 0)
2144 tdep
->sigcontext_register_address
= ia64_aix_sigcontext_register_address
;
2146 tdep
->sigcontext_register_address
= 0;
2148 /* We know that GNU/Linux won't have to resort to the
2149 native_find_global_pointer hackery. But that's the only one we
2150 know about so far, so if native_find_global_pointer is set to
2151 something non-zero, then use it. Otherwise fall back to using
2152 generic_elf_find_global_pointer. This arrangement should (in
2153 theory) allow us to cross debug GNU/Linux binaries from an AIX
2155 if (os_ident
== ELFOSABI_LINUX
)
2156 tdep
->find_global_pointer
= generic_elf_find_global_pointer
;
2157 else if (native_find_global_pointer
!= 0)
2158 tdep
->find_global_pointer
= native_find_global_pointer
;
2160 tdep
->find_global_pointer
= generic_elf_find_global_pointer
;
2162 set_gdbarch_short_bit (gdbarch
, 16);
2163 set_gdbarch_int_bit (gdbarch
, 32);
2164 set_gdbarch_long_bit (gdbarch
, 64);
2165 set_gdbarch_long_long_bit (gdbarch
, 64);
2166 set_gdbarch_float_bit (gdbarch
, 32);
2167 set_gdbarch_double_bit (gdbarch
, 64);
2168 set_gdbarch_long_double_bit (gdbarch
, 64);
2169 set_gdbarch_ptr_bit (gdbarch
, 64);
2171 set_gdbarch_num_regs (gdbarch
, ia64_num_regs
);
2172 set_gdbarch_sp_regnum (gdbarch
, sp_regnum
);
2173 set_gdbarch_fp_regnum (gdbarch
, fp_regnum
);
2174 set_gdbarch_pc_regnum (gdbarch
, pc_regnum
);
2175 set_gdbarch_fp0_regnum (gdbarch
, IA64_FR0_REGNUM
);
2177 set_gdbarch_register_name (gdbarch
, ia64_register_name
);
2178 set_gdbarch_register_size (gdbarch
, 8);
2179 set_gdbarch_register_bytes (gdbarch
, ia64_num_regs
* 8 + 128*8);
2180 set_gdbarch_register_byte (gdbarch
, ia64_register_byte
);
2181 set_gdbarch_register_raw_size (gdbarch
, ia64_register_raw_size
);
2182 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 16);
2183 set_gdbarch_register_virtual_size (gdbarch
, ia64_register_virtual_size
);
2184 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 16);
2185 set_gdbarch_register_virtual_type (gdbarch
, ia64_register_virtual_type
);
2187 set_gdbarch_skip_prologue (gdbarch
, ia64_skip_prologue
);
2189 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
2190 set_gdbarch_frameless_function_invocation (gdbarch
, ia64_frameless_function_invocation
);
2192 set_gdbarch_saved_pc_after_call (gdbarch
, ia64_saved_pc_after_call
);
2194 set_gdbarch_deprecated_frame_chain (gdbarch
, ia64_frame_chain
);
2195 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, ia64_frame_saved_pc
);
2197 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, ia64_frame_init_saved_regs
);
2198 set_gdbarch_deprecated_get_saved_register (gdbarch
, ia64_get_saved_register
);
2200 set_gdbarch_register_convertible (gdbarch
, ia64_register_convertible
);
2201 set_gdbarch_register_convert_to_virtual (gdbarch
, ia64_register_convert_to_virtual
);
2202 set_gdbarch_register_convert_to_raw (gdbarch
, ia64_register_convert_to_raw
);
2204 set_gdbarch_use_struct_convention (gdbarch
, ia64_use_struct_convention
);
2205 set_gdbarch_deprecated_extract_return_value (gdbarch
, ia64_extract_return_value
);
2207 set_gdbarch_deprecated_store_struct_return (gdbarch
, ia64_store_struct_return
);
2208 set_gdbarch_deprecated_store_return_value (gdbarch
, ia64_store_return_value
);
2209 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, ia64_extract_struct_value_address
);
2211 set_gdbarch_memory_insert_breakpoint (gdbarch
, ia64_memory_insert_breakpoint
);
2212 set_gdbarch_memory_remove_breakpoint (gdbarch
, ia64_memory_remove_breakpoint
);
2213 set_gdbarch_breakpoint_from_pc (gdbarch
, ia64_breakpoint_from_pc
);
2214 set_gdbarch_read_pc (gdbarch
, ia64_read_pc
);
2215 set_gdbarch_write_pc (gdbarch
, ia64_write_pc
);
2217 /* Settings for calling functions in the inferior. */
2218 set_gdbarch_call_dummy_length (gdbarch
, 0);
2219 set_gdbarch_push_arguments (gdbarch
, ia64_push_arguments
);
2220 set_gdbarch_push_return_address (gdbarch
, ia64_push_return_address
);
2221 set_gdbarch_deprecated_pop_frame (gdbarch
, ia64_pop_frame
);
2223 set_gdbarch_call_dummy_p (gdbarch
, 1);
2224 set_gdbarch_call_dummy_words (gdbarch
, ia64_call_dummy_words
);
2225 set_gdbarch_sizeof_call_dummy_words (gdbarch
, sizeof (ia64_call_dummy_words
));
2226 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
2227 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, ia64_init_extra_frame_info
);
2228 set_gdbarch_frame_args_address (gdbarch
, ia64_frame_args_address
);
2229 set_gdbarch_frame_locals_address (gdbarch
, ia64_frame_locals_address
);
2231 /* We won't necessarily have a frame pointer and even if we do,
2232 it winds up being extraordinarly messy when attempting to find
2233 the frame chain. So for the purposes of creating frames (which
2234 is all read_fp() is used for), simply use the stack pointer value
2236 set_gdbarch_read_fp (gdbarch
, generic_target_read_sp
);
2238 /* Settings that should be unnecessary. */
2239 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2241 set_gdbarch_read_sp (gdbarch
, generic_target_read_sp
);
2242 set_gdbarch_write_sp (gdbarch
, generic_target_write_sp
);
2244 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
2245 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
2246 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
2247 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
2249 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
2250 set_gdbarch_function_start_offset (gdbarch
, 0);
2251 set_gdbarch_frame_args_skip (gdbarch
, 0);
2253 set_gdbarch_remote_translate_xfer_address (
2254 gdbarch
, ia64_remote_translate_xfer_address
);
2260 _initialize_ia64_tdep (void)
2262 register_gdbarch_init (bfd_arch_ia64
, ia64_gdbarch_init
);
2264 tm_print_insn
= print_insn_ia64
;
2265 tm_print_insn_info
.bytes_per_line
= SLOT_MULTIPLIER
;