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"
31 #include "gdb_assert.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_breakpoint_from_pc_ftype ia64_breakpoint_from_pc
;
90 static gdbarch_skip_prologue_ftype ia64_skip_prologue
;
91 static gdbarch_deprecated_extract_return_value_ftype ia64_extract_return_value
;
92 static gdbarch_deprecated_extract_struct_value_address_ftype ia64_extract_struct_value_address
;
93 static gdbarch_use_struct_convention_ftype ia64_use_struct_convention
;
94 static gdbarch_frameless_function_invocation_ftype ia64_frameless_function_invocation
;
95 static gdbarch_deprecated_saved_pc_after_call_ftype ia64_saved_pc_after_call
;
96 static void ia64_pop_frame_regular (struct frame_info
*frame
);
97 static struct type
*is_float_or_hfa_type (struct type
*t
);
99 static int ia64_num_regs
= 590;
101 static int pc_regnum
= IA64_IP_REGNUM
;
102 static int sp_regnum
= IA64_GR12_REGNUM
;
103 static int fp_regnum
= IA64_VFP_REGNUM
;
104 static int lr_regnum
= IA64_VRAP_REGNUM
;
106 static LONGEST ia64_call_dummy_words
[] = {0};
108 /* Array of register names; There should be ia64_num_regs strings in
111 static char *ia64_register_names
[] =
112 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
113 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
114 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
115 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
116 "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
117 "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
118 "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
119 "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
120 "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
121 "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
122 "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
123 "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
124 "r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
125 "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
126 "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
127 "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
129 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
130 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
131 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
132 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
133 "f32", "f33", "f34", "f35", "f36", "f37", "f38", "f39",
134 "f40", "f41", "f42", "f43", "f44", "f45", "f46", "f47",
135 "f48", "f49", "f50", "f51", "f52", "f53", "f54", "f55",
136 "f56", "f57", "f58", "f59", "f60", "f61", "f62", "f63",
137 "f64", "f65", "f66", "f67", "f68", "f69", "f70", "f71",
138 "f72", "f73", "f74", "f75", "f76", "f77", "f78", "f79",
139 "f80", "f81", "f82", "f83", "f84", "f85", "f86", "f87",
140 "f88", "f89", "f90", "f91", "f92", "f93", "f94", "f95",
141 "f96", "f97", "f98", "f99", "f100", "f101", "f102", "f103",
142 "f104", "f105", "f106", "f107", "f108", "f109", "f110", "f111",
143 "f112", "f113", "f114", "f115", "f116", "f117", "f118", "f119",
144 "f120", "f121", "f122", "f123", "f124", "f125", "f126", "f127",
146 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
147 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
148 "p16", "p17", "p18", "p19", "p20", "p21", "p22", "p23",
149 "p24", "p25", "p26", "p27", "p28", "p29", "p30", "p31",
150 "p32", "p33", "p34", "p35", "p36", "p37", "p38", "p39",
151 "p40", "p41", "p42", "p43", "p44", "p45", "p46", "p47",
152 "p48", "p49", "p50", "p51", "p52", "p53", "p54", "p55",
153 "p56", "p57", "p58", "p59", "p60", "p61", "p62", "p63",
155 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
159 "pr", "ip", "psr", "cfm",
161 "kr0", "kr1", "kr2", "kr3", "kr4", "kr5", "kr6", "kr7",
162 "", "", "", "", "", "", "", "",
163 "rsc", "bsp", "bspstore", "rnat",
165 "eflag", "csd", "ssd", "cflg", "fsr", "fir", "fdr", "",
166 "ccv", "", "", "", "unat", "", "", "",
167 "fpsr", "", "", "", "itc",
168 "", "", "", "", "", "", "", "", "", "",
169 "", "", "", "", "", "", "", "", "",
171 "", "", "", "", "", "", "", "", "", "",
172 "", "", "", "", "", "", "", "", "", "",
173 "", "", "", "", "", "", "", "", "", "",
174 "", "", "", "", "", "", "", "", "", "",
175 "", "", "", "", "", "", "", "", "", "",
176 "", "", "", "", "", "", "", "", "", "",
178 "nat0", "nat1", "nat2", "nat3", "nat4", "nat5", "nat6", "nat7",
179 "nat8", "nat9", "nat10", "nat11", "nat12", "nat13", "nat14", "nat15",
180 "nat16", "nat17", "nat18", "nat19", "nat20", "nat21", "nat22", "nat23",
181 "nat24", "nat25", "nat26", "nat27", "nat28", "nat29", "nat30", "nat31",
182 "nat32", "nat33", "nat34", "nat35", "nat36", "nat37", "nat38", "nat39",
183 "nat40", "nat41", "nat42", "nat43", "nat44", "nat45", "nat46", "nat47",
184 "nat48", "nat49", "nat50", "nat51", "nat52", "nat53", "nat54", "nat55",
185 "nat56", "nat57", "nat58", "nat59", "nat60", "nat61", "nat62", "nat63",
186 "nat64", "nat65", "nat66", "nat67", "nat68", "nat69", "nat70", "nat71",
187 "nat72", "nat73", "nat74", "nat75", "nat76", "nat77", "nat78", "nat79",
188 "nat80", "nat81", "nat82", "nat83", "nat84", "nat85", "nat86", "nat87",
189 "nat88", "nat89", "nat90", "nat91", "nat92", "nat93", "nat94", "nat95",
190 "nat96", "nat97", "nat98", "nat99", "nat100","nat101","nat102","nat103",
191 "nat104","nat105","nat106","nat107","nat108","nat109","nat110","nat111",
192 "nat112","nat113","nat114","nat115","nat116","nat117","nat118","nat119",
193 "nat120","nat121","nat122","nat123","nat124","nat125","nat126","nat127",
196 struct frame_extra_info
198 CORE_ADDR bsp
; /* points at r32 for the current frame */
199 CORE_ADDR cfm
; /* cfm value for current frame */
200 int sof
; /* Size of frame (decoded from cfm value) */
201 int sol
; /* Size of locals (decoded from cfm value) */
202 CORE_ADDR after_prologue
;
203 /* Address of first instruction after the last
204 prologue instruction; Note that there may
205 be instructions from the function's body
206 intermingled with the prologue. */
207 int mem_stack_frame_size
;
208 /* Size of the memory stack frame (may be zero),
209 or -1 if it has not been determined yet. */
210 int fp_reg
; /* Register number (if any) used a frame pointer
211 for this frame. 0 if no register is being used
212 as the frame pointer. */
217 int os_ident
; /* From the ELF header, one of the ELFOSABI_
218 constants: ELFOSABI_LINUX, ELFOSABI_AIX,
220 CORE_ADDR (*sigcontext_register_address
) (CORE_ADDR
, int);
221 /* OS specific function which, given a frame address
222 and register number, returns the offset to the
223 given register from the start of the frame. */
224 CORE_ADDR (*find_global_pointer
) (CORE_ADDR
);
227 #define SIGCONTEXT_REGISTER_ADDRESS \
228 (gdbarch_tdep (current_gdbarch)->sigcontext_register_address)
229 #define FIND_GLOBAL_POINTER \
230 (gdbarch_tdep (current_gdbarch)->find_global_pointer)
233 ia64_register_name (int reg
)
235 return ia64_register_names
[reg
];
239 ia64_register_raw_size (int reg
)
241 return (IA64_FR0_REGNUM
<= reg
&& reg
<= IA64_FR127_REGNUM
) ? 16 : 8;
245 ia64_register_virtual_size (int reg
)
247 return (IA64_FR0_REGNUM
<= reg
&& reg
<= IA64_FR127_REGNUM
) ? 16 : 8;
250 /* Return true iff register N's virtual format is different from
253 ia64_register_convertible (int nr
)
255 return (IA64_FR0_REGNUM
<= nr
&& nr
<= IA64_FR127_REGNUM
);
258 const struct floatformat floatformat_ia64_ext
=
260 floatformat_little
, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
261 floatformat_intbit_yes
265 ia64_register_convert_to_virtual (int regnum
, struct type
*type
,
266 char *from
, char *to
)
268 if (regnum
>= IA64_FR0_REGNUM
&& regnum
<= IA64_FR127_REGNUM
)
271 floatformat_to_doublest (&floatformat_ia64_ext
, from
, &val
);
272 deprecated_store_floating (to
, TYPE_LENGTH(type
), val
);
275 error("ia64_register_convert_to_virtual called with non floating point register number");
279 ia64_register_convert_to_raw (struct type
*type
, int regnum
,
280 const char *from
, char *to
)
282 if (regnum
>= IA64_FR0_REGNUM
&& regnum
<= IA64_FR127_REGNUM
)
284 DOUBLEST val
= deprecated_extract_floating (from
, TYPE_LENGTH(type
));
285 floatformat_from_doublest (&floatformat_ia64_ext
, &val
, to
);
288 error("ia64_register_convert_to_raw called with non floating point register number");
292 ia64_register_virtual_type (int reg
)
294 if (reg
>= IA64_FR0_REGNUM
&& reg
<= IA64_FR127_REGNUM
)
295 return builtin_type_long_double
;
297 return builtin_type_long
;
301 ia64_register_byte (int reg
)
304 (reg
<= IA64_FR0_REGNUM
? 0 : 8 * ((reg
> IA64_FR127_REGNUM
) ? 128 : reg
- IA64_FR0_REGNUM
));
307 /* Read the given register from a sigcontext structure in the
311 read_sigcontext_register (struct frame_info
*frame
, int regnum
)
316 internal_error (__FILE__
, __LINE__
,
317 "read_sigcontext_register: NULL frame");
318 if (!(get_frame_type (frame
) == SIGTRAMP_FRAME
))
319 internal_error (__FILE__
, __LINE__
,
320 "read_sigcontext_register: frame not a signal trampoline");
321 if (SIGCONTEXT_REGISTER_ADDRESS
== 0)
322 internal_error (__FILE__
, __LINE__
,
323 "read_sigcontext_register: SIGCONTEXT_REGISTER_ADDRESS is 0");
325 regaddr
= SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regnum
);
327 return read_memory_integer (regaddr
, REGISTER_RAW_SIZE (regnum
));
329 internal_error (__FILE__
, __LINE__
,
330 "read_sigcontext_register: Register %d not in struct sigcontext", regnum
);
333 /* Extract ``len'' bits from an instruction bundle starting at
337 extract_bit_field (char *bundle
, int from
, int len
)
339 long long result
= 0LL;
341 int from_byte
= from
/ 8;
342 int to_byte
= to
/ 8;
343 unsigned char *b
= (unsigned char *) bundle
;
349 if (from_byte
== to_byte
)
350 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
351 result
= c
>> (from
% 8);
352 lshift
= 8 - (from
% 8);
354 for (i
= from_byte
+1; i
< to_byte
; i
++)
356 result
|= ((long long) b
[i
]) << lshift
;
360 if (from_byte
< to_byte
&& (to
% 8 != 0))
363 c
= ((unsigned char) (c
<< (8 - to
% 8))) >> (8 - to
% 8);
364 result
|= ((long long) c
) << lshift
;
370 /* Replace the specified bits in an instruction bundle */
373 replace_bit_field (char *bundle
, long long val
, int from
, int len
)
376 int from_byte
= from
/ 8;
377 int to_byte
= to
/ 8;
378 unsigned char *b
= (unsigned char *) bundle
;
381 if (from_byte
== to_byte
)
383 unsigned char left
, right
;
385 left
= (c
>> (to
% 8)) << (to
% 8);
386 right
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
387 c
= (unsigned char) (val
& 0xff);
388 c
= (unsigned char) (c
<< (from
% 8 + 8 - to
% 8)) >> (8 - to
% 8);
396 c
= ((unsigned char) (c
<< (8 - from
% 8))) >> (8 - from
% 8);
397 c
= c
| (val
<< (from
% 8));
399 val
>>= 8 - from
% 8;
401 for (i
= from_byte
+1; i
< to_byte
; i
++)
410 unsigned char cv
= (unsigned char) val
;
412 c
= c
>> (to
% 8) << (to
% 8);
413 c
|= ((unsigned char) (cv
<< (8 - to
% 8))) >> (8 - to
% 8);
419 /* Return the contents of slot N (for N = 0, 1, or 2) in
420 and instruction bundle */
423 slotN_contents (char *bundle
, int slotnum
)
425 return extract_bit_field (bundle
, 5+41*slotnum
, 41);
428 /* Store an instruction in an instruction bundle */
431 replace_slotN_contents (char *bundle
, long long instr
, int slotnum
)
433 replace_bit_field (bundle
, instr
, 5+41*slotnum
, 41);
436 static enum instruction_type template_encoding_table
[32][3] =
438 { M
, I
, I
}, /* 00 */
439 { M
, I
, I
}, /* 01 */
440 { M
, I
, I
}, /* 02 */
441 { M
, I
, I
}, /* 03 */
442 { M
, L
, X
}, /* 04 */
443 { M
, L
, X
}, /* 05 */
444 { undefined
, undefined
, undefined
}, /* 06 */
445 { undefined
, undefined
, undefined
}, /* 07 */
446 { M
, M
, I
}, /* 08 */
447 { M
, M
, I
}, /* 09 */
448 { M
, M
, I
}, /* 0A */
449 { M
, M
, I
}, /* 0B */
450 { M
, F
, I
}, /* 0C */
451 { M
, F
, I
}, /* 0D */
452 { M
, M
, F
}, /* 0E */
453 { M
, M
, F
}, /* 0F */
454 { M
, I
, B
}, /* 10 */
455 { M
, I
, B
}, /* 11 */
456 { M
, B
, B
}, /* 12 */
457 { M
, B
, B
}, /* 13 */
458 { undefined
, undefined
, undefined
}, /* 14 */
459 { undefined
, undefined
, undefined
}, /* 15 */
460 { B
, B
, B
}, /* 16 */
461 { B
, B
, B
}, /* 17 */
462 { M
, M
, B
}, /* 18 */
463 { M
, M
, B
}, /* 19 */
464 { undefined
, undefined
, undefined
}, /* 1A */
465 { undefined
, undefined
, undefined
}, /* 1B */
466 { M
, F
, B
}, /* 1C */
467 { M
, F
, B
}, /* 1D */
468 { undefined
, undefined
, undefined
}, /* 1E */
469 { undefined
, undefined
, undefined
}, /* 1F */
472 /* Fetch and (partially) decode an instruction at ADDR and return the
473 address of the next instruction to fetch. */
476 fetch_instruction (CORE_ADDR addr
, instruction_type
*it
, long long *instr
)
478 char bundle
[BUNDLE_LEN
];
479 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
483 /* Warn about slot numbers greater than 2. We used to generate
484 an error here on the assumption that the user entered an invalid
485 address. But, sometimes GDB itself requests an invalid address.
486 This can (easily) happen when execution stops in a function for
487 which there are no symbols. The prologue scanner will attempt to
488 find the beginning of the function - if the nearest symbol
489 happens to not be aligned on a bundle boundary (16 bytes), the
490 resulting starting address will cause GDB to think that the slot
493 So we warn about it and set the slot number to zero. It is
494 not necessarily a fatal condition, particularly if debugging
495 at the assembly language level. */
498 warning ("Can't fetch instructions for slot numbers greater than 2.\n"
499 "Using slot 0 instead");
505 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
510 *instr
= slotN_contents (bundle
, slotnum
);
511 template = extract_bit_field (bundle
, 0, 5);
512 *it
= template_encoding_table
[(int)template][slotnum
];
514 if (slotnum
== 2 || (slotnum
== 1 && *it
== L
))
517 addr
+= (slotnum
+ 1) * SLOT_MULTIPLIER
;
522 /* There are 5 different break instructions (break.i, break.b,
523 break.m, break.f, and break.x), but they all have the same
524 encoding. (The five bit template in the low five bits of the
525 instruction bundle distinguishes one from another.)
527 The runtime architecture manual specifies that break instructions
528 used for debugging purposes must have the upper two bits of the 21
529 bit immediate set to a 0 and a 1 respectively. A breakpoint
530 instruction encodes the most significant bit of its 21 bit
531 immediate at bit 36 of the 41 bit instruction. The penultimate msb
532 is at bit 25 which leads to the pattern below.
534 Originally, I had this set up to do, e.g, a "break.i 0x80000" But
535 it turns out that 0x80000 was used as the syscall break in the early
536 simulators. So I changed the pattern slightly to do "break.i 0x080001"
537 instead. But that didn't work either (I later found out that this
538 pattern was used by the simulator that I was using.) So I ended up
539 using the pattern seen below. */
542 #define IA64_BREAKPOINT 0x00002000040LL
544 #define IA64_BREAKPOINT 0x00003333300LL
547 ia64_memory_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
549 char bundle
[BUNDLE_LEN
];
550 int slotnum
= (int) (addr
& 0x0f) / SLOT_MULTIPLIER
;
556 error("Can't insert breakpoint for slot numbers greater than 2.");
560 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
562 /* Check for L type instruction in 2nd slot, if present then
563 bump up the slot number to the 3rd slot */
564 template = extract_bit_field (bundle
, 0, 5);
565 if (slotnum
== 1 && template_encoding_table
[template][1] == L
)
570 instr
= slotN_contents (bundle
, slotnum
);
571 memcpy(contents_cache
, &instr
, sizeof(instr
));
572 replace_slotN_contents (bundle
, IA64_BREAKPOINT
, slotnum
);
574 target_write_memory (addr
, bundle
, BUNDLE_LEN
);
580 ia64_memory_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
582 char bundle
[BUNDLE_LEN
];
583 int slotnum
= (addr
& 0x0f) / SLOT_MULTIPLIER
;
590 val
= target_read_memory (addr
, bundle
, BUNDLE_LEN
);
592 /* Check for L type instruction in 2nd slot, if present then
593 bump up the slot number to the 3rd slot */
594 template = extract_bit_field (bundle
, 0, 5);
595 if (slotnum
== 1 && template_encoding_table
[template][1] == L
)
600 memcpy (&instr
, contents_cache
, sizeof instr
);
601 replace_slotN_contents (bundle
, instr
, slotnum
);
603 target_write_memory (addr
, bundle
, BUNDLE_LEN
);
608 /* We don't really want to use this, but remote.c needs to call it in order
609 to figure out if Z-packets are supported or not. Oh, well. */
610 const unsigned char *
611 ia64_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
613 static unsigned char breakpoint
[] =
614 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
615 *lenptr
= sizeof (breakpoint
);
625 /* We won't necessarily have a frame pointer and even if we do, it
626 winds up being extraordinarly messy when attempting to find the
627 frame chain. So for the purposes of creating frames (which is
628 all deprecated_read_fp() is used for), simply use the stack
629 pointer value instead. */
630 gdb_assert (SP_REGNUM
>= 0);
631 return read_register (SP_REGNUM
);
635 ia64_read_pc (ptid_t ptid
)
637 CORE_ADDR psr_value
= read_register_pid (IA64_PSR_REGNUM
, ptid
);
638 CORE_ADDR pc_value
= read_register_pid (IA64_IP_REGNUM
, ptid
);
639 int slot_num
= (psr_value
>> 41) & 3;
641 return pc_value
| (slot_num
* SLOT_MULTIPLIER
);
645 ia64_write_pc (CORE_ADDR new_pc
, ptid_t ptid
)
647 int slot_num
= (int) (new_pc
& 0xf) / SLOT_MULTIPLIER
;
648 CORE_ADDR psr_value
= read_register_pid (IA64_PSR_REGNUM
, ptid
);
649 psr_value
&= ~(3LL << 41);
650 psr_value
|= (CORE_ADDR
)(slot_num
& 0x3) << 41;
654 write_register_pid (IA64_PSR_REGNUM
, psr_value
, ptid
);
655 write_register_pid (IA64_IP_REGNUM
, new_pc
, ptid
);
658 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
660 /* Returns the address of the slot that's NSLOTS slots away from
661 the address ADDR. NSLOTS may be positive or negative. */
663 rse_address_add(CORE_ADDR addr
, int nslots
)
666 int mandatory_nat_slots
= nslots
/ 63;
667 int direction
= nslots
< 0 ? -1 : 1;
669 new_addr
= addr
+ 8 * (nslots
+ mandatory_nat_slots
);
671 if ((new_addr
>> 9) != ((addr
+ 8 * 64 * mandatory_nat_slots
) >> 9))
672 new_addr
+= 8 * direction
;
674 if (IS_NaT_COLLECTION_ADDR(new_addr
))
675 new_addr
+= 8 * direction
;
680 /* The IA-64 frame chain is a bit odd. We won't always have a frame
681 pointer, so we use the SP value as the FP for the purpose of
682 creating a frame. There is sometimes a register (not fixed) which
683 is used as a frame pointer. When this register exists, it is not
684 especially hard to determine which one is being used. It isn't
685 even really hard to compute the frame chain, but it can be
686 computationally expensive. So, instead of making life difficult
687 (and slow), we pick a more convenient representation of the frame
688 chain, knowing that we'll have to make some small adjustments in
689 other places. (E.g, note that deprecated_read_fp() is actually
690 read_sp() in ia64_gdbarch_init() below.)
692 Okay, so what is the frame chain exactly? It'll be the SP value
693 at the time that the function in question was entered.
695 Note that this *should* actually the frame pointer for the current
696 function! But as I note above, if we were to attempt to find the
697 address of the beginning of the previous frame, we'd waste a lot
698 of cycles for no good reason. So instead, we simply choose to
699 represent the frame chain as the end of the previous frame instead
703 ia64_frame_chain (struct frame_info
*frame
)
705 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
706 return read_sigcontext_register (frame
, sp_regnum
);
707 else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
708 get_frame_base (frame
),
709 get_frame_base (frame
)))
710 return get_frame_base (frame
);
713 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
714 if (get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
])
715 return read_memory_integer (get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
], 8);
717 return (get_frame_base (frame
)
718 + get_frame_extra_info (frame
)->mem_stack_frame_size
);
723 ia64_frame_saved_pc (struct frame_info
*frame
)
725 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
726 return read_sigcontext_register (frame
, pc_regnum
);
727 else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
728 get_frame_base (frame
),
729 get_frame_base (frame
)))
730 return deprecated_read_register_dummy (get_frame_pc (frame
),
731 get_frame_base (frame
), pc_regnum
);
734 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
736 if (get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
])
737 return read_memory_integer (get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
], 8);
738 else if (get_next_frame (frame
)
739 && (get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
))
740 return read_sigcontext_register (get_next_frame (frame
), IA64_BR0_REGNUM
);
741 else /* either frameless, or not far enough along in the prologue... */
742 return ia64_saved_pc_after_call (frame
);
746 /* Limit the number of skipped non-prologue instructions since examining
747 of the prologue is expensive. */
748 static int max_skip_non_prologue_insns
= 40;
750 /* Given PC representing the starting address of a function, and
751 LIM_PC which is the (sloppy) limit to which to scan when looking
752 for a prologue, attempt to further refine this limit by using
753 the line data in the symbol table. If successful, a better guess
754 on where the prologue ends is returned, otherwise the previous
755 value of lim_pc is returned. TRUST_LIMIT is a pointer to a flag
756 which will be set to indicate whether the returned limit may be
757 used with no further scanning in the event that the function is
761 refine_prologue_limit (CORE_ADDR pc
, CORE_ADDR lim_pc
, int *trust_limit
)
763 struct symtab_and_line prologue_sal
;
764 CORE_ADDR start_pc
= pc
;
766 /* Start off not trusting the limit. */
769 prologue_sal
= find_pc_line (pc
, 0);
770 if (prologue_sal
.line
!= 0)
773 CORE_ADDR addr
= prologue_sal
.end
;
775 /* Handle the case in which compiler's optimizer/scheduler
776 has moved instructions into the prologue. We scan ahead
777 in the function looking for address ranges whose corresponding
778 line number is less than or equal to the first one that we
779 found for the function. (It can be less than when the
780 scheduler puts a body instruction before the first prologue
782 for (i
= 2 * max_skip_non_prologue_insns
;
783 i
> 0 && (lim_pc
== 0 || addr
< lim_pc
);
786 struct symtab_and_line sal
;
788 sal
= find_pc_line (addr
, 0);
791 if (sal
.line
<= prologue_sal
.line
792 && sal
.symtab
== prologue_sal
.symtab
)
799 if (lim_pc
== 0 || prologue_sal
.end
< lim_pc
)
801 lim_pc
= prologue_sal
.end
;
802 if (start_pc
== get_pc_function_start (lim_pc
))
809 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
810 || (8 <= (_regnum_) && (_regnum_) <= 11) \
811 || (14 <= (_regnum_) && (_regnum_) <= 31))
812 #define imm9(_instr_) \
813 ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
814 | (((_instr_) & 0x00008000000LL) >> 20) \
815 | (((_instr_) & 0x00000001fc0LL) >> 6))
818 examine_prologue (CORE_ADDR pc
, CORE_ADDR lim_pc
, struct frame_info
*frame
)
821 CORE_ADDR last_prologue_pc
= pc
;
824 int do_fsr_stuff
= 0;
829 int unat_save_reg
= 0;
831 int mem_stack_frame_size
= 0;
833 CORE_ADDR spill_addr
= 0;
836 char reg_contents
[256];
840 memset (instores
, 0, sizeof instores
);
841 memset (infpstores
, 0, sizeof infpstores
);
842 memset (reg_contents
, 0, sizeof reg_contents
);
844 if (frame
&& !get_frame_saved_regs (frame
))
846 frame_saved_regs_zalloc (frame
);
852 && get_frame_extra_info (frame
)->after_prologue
!= 0
853 && get_frame_extra_info (frame
)->after_prologue
<= lim_pc
)
854 return get_frame_extra_info (frame
)->after_prologue
;
856 lim_pc
= refine_prologue_limit (pc
, lim_pc
, &trust_limit
);
857 next_pc
= fetch_instruction (pc
, &it
, &instr
);
859 /* We want to check if we have a recognizable function start before we
860 look ahead for a prologue. */
861 if (pc
< lim_pc
&& next_pc
862 && it
== M
&& ((instr
& 0x1ee0000003fLL
) == 0x02c00000000LL
))
864 /* alloc - start of a regular function. */
865 int sor
= (int) ((instr
& 0x00078000000LL
) >> 27);
866 int sol
= (int) ((instr
& 0x00007f00000LL
) >> 20);
867 int sof
= (int) ((instr
& 0x000000fe000LL
) >> 13);
868 /* Okay, so sor, sol, and sof aren't used right now; but perhaps
869 we could compare against the size given to us via the cfm as
870 either a sanity check or possibly to see if the frame has been
871 changed by a later alloc instruction... */
872 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
874 last_prologue_pc
= next_pc
;
879 /* Look for a leaf routine. */
880 if (pc
< lim_pc
&& next_pc
881 && (it
== I
|| it
== M
)
882 && ((instr
& 0x1ee00000000LL
) == 0x10800000000LL
))
884 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
885 int imm
= (int) ((((instr
& 0x01000000000LL
) ? -1 : 0) << 13)
886 | ((instr
& 0x001f8000000LL
) >> 20)
887 | ((instr
& 0x000000fe000LL
) >> 13));
888 int rM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
889 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
890 int qp
= (int) (instr
& 0x0000000003fLL
);
891 if (qp
== 0 && rN
== 2 && imm
== 0 && rM
== 12 && fp_reg
== 0)
893 /* mov r2, r12 - beginning of leaf routine */
896 last_prologue_pc
= next_pc
;
900 /* If we don't recognize a regular function or leaf routine, we are
906 last_prologue_pc
= lim_pc
;
910 /* Loop, looking for prologue instructions, keeping track of
911 where preserved registers were spilled. */
914 next_pc
= fetch_instruction (pc
, &it
, &instr
);
918 if ((it
== B
&& ((instr
& 0x1e1f800003f) != 0x04000000000))
919 || ((instr
& 0x3fLL
) != 0LL))
921 /* Exit loop upon hitting a non-nop branch instruction
922 or a predicated instruction. */
927 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00188000000LL
))
930 int b2
= (int) ((instr
& 0x0000000e000LL
) >> 13);
931 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
932 int qp
= (int) (instr
& 0x0000000003f);
934 if (qp
== 0 && b2
== 0 && rN
>= 32 && ret_reg
== 0)
937 last_prologue_pc
= next_pc
;
940 else if ((it
== I
|| it
== M
)
941 && ((instr
& 0x1ee00000000LL
) == 0x10800000000LL
))
943 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
944 int imm
= (int) ((((instr
& 0x01000000000LL
) ? -1 : 0) << 13)
945 | ((instr
& 0x001f8000000LL
) >> 20)
946 | ((instr
& 0x000000fe000LL
) >> 13));
947 int rM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
948 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
949 int qp
= (int) (instr
& 0x0000000003fLL
);
951 if (qp
== 0 && rN
>= 32 && imm
== 0 && rM
== 12 && fp_reg
== 0)
955 last_prologue_pc
= next_pc
;
957 else if (qp
== 0 && rN
== 12 && rM
== 12)
959 /* adds r12, -mem_stack_frame_size, r12 */
960 mem_stack_frame_size
-= imm
;
961 last_prologue_pc
= next_pc
;
963 else if (qp
== 0 && rN
== 2
964 && ((rM
== fp_reg
&& fp_reg
!= 0) || rM
== 12))
966 /* adds r2, spilloffset, rFramePointer
968 adds r2, spilloffset, r12
970 Get ready for stf.spill or st8.spill instructions.
971 The address to start spilling at is loaded into r2.
972 FIXME: Why r2? That's what gcc currently uses; it
973 could well be different for other compilers. */
975 /* Hmm... whether or not this will work will depend on
976 where the pc is. If it's still early in the prologue
977 this'll be wrong. FIXME */
978 spill_addr
= (frame
? get_frame_base (frame
) : 0)
979 + (rM
== 12 ? 0 : mem_stack_frame_size
)
982 last_prologue_pc
= next_pc
;
984 else if (qp
== 0 && rM
>= 32 && rM
< 40 && !instores
[rM
] &&
985 rN
< 256 && imm
== 0)
987 /* mov rN, rM where rM is an input register */
988 reg_contents
[rN
] = rM
;
989 last_prologue_pc
= next_pc
;
991 else if (frameless
&& qp
== 0 && rN
== fp_reg
&& imm
== 0 &&
995 last_prologue_pc
= next_pc
;
1000 && ( ((instr
& 0x1efc0000000LL
) == 0x0eec0000000LL
)
1001 || ((instr
& 0x1ffc8000000LL
) == 0x0cec0000000LL
) ))
1003 /* stf.spill [rN] = fM, imm9
1005 stf.spill [rN] = fM */
1007 int imm
= imm9(instr
);
1008 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1009 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1010 int qp
= (int) (instr
& 0x0000000003fLL
);
1011 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
1012 && ((2 <= fM
&& fM
<= 5) || (16 <= fM
&& fM
<= 31)))
1015 get_frame_saved_regs (frame
)[IA64_FR0_REGNUM
+ fM
] = spill_addr
;
1017 if ((instr
& 0x1efc0000000) == 0x0eec0000000)
1020 spill_addr
= 0; /* last one; must be done */
1021 last_prologue_pc
= next_pc
;
1024 else if ((it
== M
&& ((instr
& 0x1eff8000000LL
) == 0x02110000000LL
))
1025 || (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00050000000LL
)) )
1031 int arM
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1032 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1033 int qp
= (int) (instr
& 0x0000000003fLL
);
1034 if (qp
== 0 && isScratch (rN
) && arM
== 36 /* ar.unat */)
1036 /* We have something like "mov.m r3 = ar.unat". Remember the
1037 r3 (or whatever) and watch for a store of this register... */
1039 last_prologue_pc
= next_pc
;
1042 else if (it
== I
&& ((instr
& 0x1eff8000000LL
) == 0x00198000000LL
))
1045 int rN
= (int) ((instr
& 0x00000001fc0LL
) >> 6);
1046 int qp
= (int) (instr
& 0x0000000003fLL
);
1047 if (qp
== 0 && isScratch (rN
))
1050 last_prologue_pc
= next_pc
;
1054 && ( ((instr
& 0x1ffc8000000LL
) == 0x08cc0000000LL
)
1055 || ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)))
1059 st8 [rN] = rM, imm9 */
1060 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1061 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1062 int qp
= (int) (instr
& 0x0000000003fLL
);
1063 int indirect
= rM
< 256 ? reg_contents
[rM
] : 0;
1064 if (qp
== 0 && rN
== spill_reg
&& spill_addr
!= 0
1065 && (rM
== unat_save_reg
|| rM
== pr_save_reg
))
1067 /* We've found a spill of either the UNAT register or the PR
1068 register. (Well, not exactly; what we've actually found is
1069 a spill of the register that UNAT or PR was moved to).
1070 Record that fact and move on... */
1071 if (rM
== unat_save_reg
)
1073 /* Track UNAT register */
1075 get_frame_saved_regs (frame
)[IA64_UNAT_REGNUM
] = spill_addr
;
1080 /* Track PR register */
1082 get_frame_saved_regs (frame
)[IA64_PR_REGNUM
] = spill_addr
;
1085 if ((instr
& 0x1efc0000000LL
) == 0x0acc0000000LL
)
1086 /* st8 [rN] = rM, imm9 */
1087 spill_addr
+= imm9(instr
);
1089 spill_addr
= 0; /* must be done spilling */
1090 last_prologue_pc
= next_pc
;
1092 else if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1094 /* Allow up to one store of each input register. */
1095 instores
[rM
-32] = 1;
1096 last_prologue_pc
= next_pc
;
1098 else if (qp
== 0 && 32 <= indirect
&& indirect
< 40 &&
1099 !instores
[indirect
-32])
1101 /* Allow an indirect store of an input register. */
1102 instores
[indirect
-32] = 1;
1103 last_prologue_pc
= next_pc
;
1106 else if (it
== M
&& ((instr
& 0x1ff08000000LL
) == 0x08c00000000LL
))
1113 Note that the st8 case is handled in the clause above.
1115 Advance over stores of input registers. One store per input
1116 register is permitted. */
1117 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1118 int qp
= (int) (instr
& 0x0000000003fLL
);
1119 int indirect
= rM
< 256 ? reg_contents
[rM
] : 0;
1120 if (qp
== 0 && 32 <= rM
&& rM
< 40 && !instores
[rM
-32])
1122 instores
[rM
-32] = 1;
1123 last_prologue_pc
= next_pc
;
1125 else if (qp
== 0 && 32 <= indirect
&& indirect
< 40 &&
1126 !instores
[indirect
-32])
1128 /* Allow an indirect store of an input register. */
1129 instores
[indirect
-32] = 1;
1130 last_prologue_pc
= next_pc
;
1133 else if (it
== M
&& ((instr
& 0x1ff88000000LL
) == 0x0cc80000000LL
))
1140 Advance over stores of floating point input registers. Again
1141 one store per register is permitted */
1142 int fM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1143 int qp
= (int) (instr
& 0x0000000003fLL
);
1144 if (qp
== 0 && 8 <= fM
&& fM
< 16 && !infpstores
[fM
- 8])
1146 infpstores
[fM
-8] = 1;
1147 last_prologue_pc
= next_pc
;
1151 && ( ((instr
& 0x1ffc8000000LL
) == 0x08ec0000000LL
)
1152 || ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)))
1154 /* st8.spill [rN] = rM
1156 st8.spill [rN] = rM, imm9 */
1157 int rN
= (int) ((instr
& 0x00007f00000LL
) >> 20);
1158 int rM
= (int) ((instr
& 0x000000fe000LL
) >> 13);
1159 int qp
= (int) (instr
& 0x0000000003fLL
);
1160 if (qp
== 0 && rN
== spill_reg
&& 4 <= rM
&& rM
<= 7)
1162 /* We've found a spill of one of the preserved general purpose
1163 regs. Record the spill address and advance the spill
1164 register if appropriate. */
1166 get_frame_saved_regs (frame
)[IA64_GR0_REGNUM
+ rM
] = spill_addr
;
1167 if ((instr
& 0x1efc0000000LL
) == 0x0aec0000000LL
)
1168 /* st8.spill [rN] = rM, imm9 */
1169 spill_addr
+= imm9(instr
);
1171 spill_addr
= 0; /* Done spilling */
1172 last_prologue_pc
= next_pc
;
1184 /* Extract the size of the rotating portion of the stack
1185 frame and the register rename base from the current
1187 sor
= ((get_frame_extra_info (frame
)->cfm
>> 14) & 0xf) * 8;
1188 rrb_gr
= (get_frame_extra_info (frame
)->cfm
>> 18) & 0x7f;
1190 for (i
= 0, addr
= get_frame_extra_info (frame
)->bsp
;
1191 i
< get_frame_extra_info (frame
)->sof
;
1194 if (IS_NaT_COLLECTION_ADDR (addr
))
1199 get_frame_saved_regs (frame
)[IA64_GR32_REGNUM
+ ((i
+ (sor
- rrb_gr
)) % sor
)]
1202 get_frame_saved_regs (frame
)[IA64_GR32_REGNUM
+ i
] = addr
;
1204 if (i
+32 == cfm_reg
)
1205 get_frame_saved_regs (frame
)[IA64_CFM_REGNUM
] = addr
;
1206 if (i
+32 == ret_reg
)
1207 get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
] = addr
;
1209 get_frame_saved_regs (frame
)[IA64_VFP_REGNUM
] = addr
;
1213 if (frame
&& get_frame_extra_info (frame
))
1215 get_frame_extra_info (frame
)->after_prologue
= last_prologue_pc
;
1216 get_frame_extra_info (frame
)->mem_stack_frame_size
= mem_stack_frame_size
;
1217 get_frame_extra_info (frame
)->fp_reg
= fp_reg
;
1220 /* Try and trust the lim_pc value whenever possible. */
1221 if (trust_limit
&& lim_pc
>= last_prologue_pc
)
1224 return last_prologue_pc
;
1228 ia64_skip_prologue (CORE_ADDR pc
)
1230 return examine_prologue (pc
, pc
+1024, 0);
1234 ia64_frame_init_saved_regs (struct frame_info
*frame
)
1236 if (get_frame_saved_regs (frame
))
1239 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
) && SIGCONTEXT_REGISTER_ADDRESS
)
1243 frame_saved_regs_zalloc (frame
);
1245 get_frame_saved_regs (frame
)[IA64_VRAP_REGNUM
] =
1246 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_IP_REGNUM
);
1247 get_frame_saved_regs (frame
)[IA64_CFM_REGNUM
] =
1248 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_CFM_REGNUM
);
1249 get_frame_saved_regs (frame
)[IA64_PSR_REGNUM
] =
1250 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_PSR_REGNUM
);
1252 get_frame_saved_regs (frame
)[IA64_BSP_REGNUM
] =
1253 SIGCONTEXT_REGISTER_ADDRESS (frame
->frame
, IA64_BSP_REGNUM
);
1255 get_frame_saved_regs (frame
)[IA64_RNAT_REGNUM
] =
1256 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_RNAT_REGNUM
);
1257 get_frame_saved_regs (frame
)[IA64_CCV_REGNUM
] =
1258 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_CCV_REGNUM
);
1259 get_frame_saved_regs (frame
)[IA64_UNAT_REGNUM
] =
1260 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_UNAT_REGNUM
);
1261 get_frame_saved_regs (frame
)[IA64_FPSR_REGNUM
] =
1262 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_FPSR_REGNUM
);
1263 get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
] =
1264 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_PFS_REGNUM
);
1265 get_frame_saved_regs (frame
)[IA64_LC_REGNUM
] =
1266 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), IA64_LC_REGNUM
);
1267 for (regno
= IA64_GR1_REGNUM
; regno
<= IA64_GR31_REGNUM
; regno
++)
1268 if (regno
!= sp_regnum
)
1269 get_frame_saved_regs (frame
)[regno
] =
1270 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1271 for (regno
= IA64_BR0_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
1272 get_frame_saved_regs (frame
)[regno
] =
1273 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1274 for (regno
= IA64_FR2_REGNUM
; regno
<= IA64_BR7_REGNUM
; regno
++)
1275 get_frame_saved_regs (frame
)[regno
] =
1276 SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame
), regno
);
1280 CORE_ADDR func_start
;
1282 func_start
= get_frame_func (frame
);
1283 examine_prologue (func_start
, get_frame_pc (frame
), frame
);
1288 ia64_get_saved_register (char *raw_buffer
,
1291 struct frame_info
*frame
,
1293 enum lval_type
*lval
)
1297 if (!target_has_registers
)
1298 error ("No registers.");
1300 if (optimized
!= NULL
)
1309 is_dummy_frame
= DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
1310 get_frame_base (frame
),
1311 get_frame_base (frame
));
1313 if (regnum
== SP_REGNUM
&& get_next_frame (frame
))
1315 /* Handle SP values for all frames but the topmost. */
1316 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1317 get_frame_base (frame
));
1319 else if (regnum
== IA64_BSP_REGNUM
)
1321 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1322 get_frame_extra_info (frame
)->bsp
);
1324 else if (regnum
== IA64_VFP_REGNUM
)
1326 /* If the function in question uses an automatic register (r32-r127)
1327 for the frame pointer, it'll be found by ia64_find_saved_register()
1328 above. If the function lacks one of these frame pointers, we can
1329 still provide a value since we know the size of the frame */
1330 CORE_ADDR vfp
= (get_frame_base (frame
)
1331 + get_frame_extra_info (frame
)->mem_stack_frame_size
);
1332 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (IA64_VFP_REGNUM
), vfp
);
1334 else if (IA64_PR0_REGNUM
<= regnum
&& regnum
<= IA64_PR63_REGNUM
)
1336 char pr_raw_buffer
[MAX_REGISTER_SIZE
];
1338 enum lval_type pr_lval
;
1341 ia64_get_saved_register (pr_raw_buffer
, &pr_optim
, &pr_addr
,
1342 frame
, IA64_PR_REGNUM
, &pr_lval
);
1343 if (IA64_PR16_REGNUM
<= regnum
&& regnum
<= IA64_PR63_REGNUM
)
1345 /* Fetch predicate register rename base from current frame
1346 marker for this frame. */
1347 int rrb_pr
= (get_frame_extra_info (frame
)->cfm
>> 32) & 0x3f;
1349 /* Adjust the register number to account for register rotation. */
1350 regnum
= IA64_PR16_REGNUM
1351 + ((regnum
- IA64_PR16_REGNUM
) + rrb_pr
) % 48;
1353 prN_val
= extract_bit_field ((unsigned char *) pr_raw_buffer
,
1354 regnum
- IA64_PR0_REGNUM
, 1);
1355 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), prN_val
);
1357 else if (IA64_NAT0_REGNUM
<= regnum
&& regnum
<= IA64_NAT31_REGNUM
)
1359 char unat_raw_buffer
[MAX_REGISTER_SIZE
];
1361 enum lval_type unat_lval
;
1362 CORE_ADDR unat_addr
;
1364 ia64_get_saved_register (unat_raw_buffer
, &unat_optim
, &unat_addr
,
1365 frame
, IA64_UNAT_REGNUM
, &unat_lval
);
1366 unatN_val
= extract_bit_field ((unsigned char *) unat_raw_buffer
,
1367 regnum
- IA64_NAT0_REGNUM
, 1);
1368 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1371 else if (IA64_NAT32_REGNUM
<= regnum
&& regnum
<= IA64_NAT127_REGNUM
)
1374 /* Find address of general register corresponding to nat bit we're
1376 CORE_ADDR gr_addr
= 0;
1378 if (!is_dummy_frame
)
1380 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1381 gr_addr
= get_frame_saved_regs (frame
)[ regnum
- IA64_NAT0_REGNUM
1386 /* Compute address of nat collection bits */
1387 CORE_ADDR nat_addr
= gr_addr
| 0x1f8;
1388 CORE_ADDR bsp
= read_register (IA64_BSP_REGNUM
);
1389 CORE_ADDR nat_collection
;
1391 /* If our nat collection address is bigger than bsp, we have to get
1392 the nat collection from rnat. Otherwise, we fetch the nat
1393 collection from the computed address. */
1394 if (nat_addr
>= bsp
)
1395 nat_collection
= read_register (IA64_RNAT_REGNUM
);
1397 nat_collection
= read_memory_integer (nat_addr
, 8);
1398 nat_bit
= (gr_addr
>> 3) & 0x3f;
1399 natval
= (nat_collection
>> nat_bit
) & 1;
1401 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), natval
);
1403 else if (regnum
== IA64_IP_REGNUM
)
1406 if (get_next_frame (frame
))
1408 /* FIXME: Set *addrp, *lval when possible. */
1409 pc
= ia64_frame_saved_pc (get_next_frame (frame
));
1415 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (IA64_IP_REGNUM
), pc
);
1417 else if (IA64_GR32_REGNUM
<= regnum
&& regnum
<= IA64_GR127_REGNUM
)
1420 if (!is_dummy_frame
)
1422 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1423 addr
= get_frame_saved_regs (frame
)[regnum
];
1429 *lval
= lval_memory
;
1432 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1436 /* r32 - r127 must be fetchable via memory. If they aren't,
1437 then the register is unavailable */
1438 memset (raw_buffer
, 0, REGISTER_RAW_SIZE (regnum
));
1443 if (IA64_FR32_REGNUM
<= regnum
&& regnum
<= IA64_FR127_REGNUM
)
1445 /* Fetch floating point register rename base from current
1446 frame marker for this frame. */
1447 int rrb_fr
= (get_frame_extra_info (frame
)->cfm
>> 25) & 0x7f;
1449 /* Adjust the floating point register number to account for
1450 register rotation. */
1451 regnum
= IA64_FR32_REGNUM
1452 + ((regnum
- IA64_FR32_REGNUM
) + rrb_fr
) % 96;
1455 deprecated_generic_get_saved_register (raw_buffer
, optimized
, addrp
,
1456 frame
, regnum
, lval
);
1460 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1461 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1462 and TYPE is the type (which is known to be struct, union or array). */
1464 ia64_use_struct_convention (int gcc_p
, struct type
*type
)
1466 struct type
*float_elt_type
;
1468 /* HFAs are structures (or arrays) consisting entirely of floating
1469 point values of the same length. Up to 8 of these are returned
1470 in registers. Don't use the struct convention when this is the
1472 float_elt_type
= is_float_or_hfa_type (type
);
1473 if (float_elt_type
!= NULL
1474 && TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
) <= 8)
1477 /* Other structs of length 32 or less are returned in r8-r11.
1478 Don't use the struct convention for those either. */
1479 return TYPE_LENGTH (type
) > 32;
1483 ia64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
1485 struct type
*float_elt_type
;
1487 float_elt_type
= is_float_or_hfa_type (type
);
1488 if (float_elt_type
!= NULL
)
1491 int regnum
= IA64_FR8_REGNUM
;
1492 int n
= TYPE_LENGTH (type
) / TYPE_LENGTH (float_elt_type
);
1496 ia64_register_convert_to_virtual (regnum
, float_elt_type
,
1497 ®buf
[REGISTER_BYTE (regnum
)], valbuf
+ offset
);
1498 offset
+= TYPE_LENGTH (float_elt_type
);
1503 memcpy (valbuf
, ®buf
[REGISTER_BYTE (IA64_GR8_REGNUM
)],
1504 TYPE_LENGTH (type
));
1507 /* FIXME: Turn this into a stack of some sort. Unfortunately, something
1508 like this is necessary though since the IA-64 calling conventions specify
1509 that r8 is not preserved. */
1510 static CORE_ADDR struct_return_address
;
1513 ia64_extract_struct_value_address (char *regbuf
)
1515 /* FIXME: See above. */
1516 return struct_return_address
;
1520 ia64_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1522 /* FIXME: See above. */
1523 /* Note that most of the work was done in ia64_push_arguments() */
1524 struct_return_address
= addr
;
1528 ia64_frameless_function_invocation (struct frame_info
*frame
)
1530 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1531 return (get_frame_extra_info (frame
)->mem_stack_frame_size
== 0);
1535 ia64_saved_pc_after_call (struct frame_info
*frame
)
1537 return read_register (IA64_BR0_REGNUM
);
1541 ia64_frame_args_address (struct frame_info
*frame
)
1543 /* frame->frame points at the SP for this frame; But we want the start
1544 of the frame, not the end. Calling frame chain will get his for us. */
1545 return ia64_frame_chain (frame
);
1549 ia64_frame_locals_address (struct frame_info
*frame
)
1551 /* frame->frame points at the SP for this frame; But we want the start
1552 of the frame, not the end. Calling frame chain will get his for us. */
1553 return ia64_frame_chain (frame
);
1557 ia64_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
1560 int next_frame_is_call_dummy
= ((get_next_frame (frame
) != NULL
)
1561 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frame
)),
1562 get_frame_base (get_next_frame (frame
)),
1563 get_frame_base (get_next_frame (frame
))));
1565 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
1567 if (get_next_frame (frame
) == 0)
1569 bsp
= read_register (IA64_BSP_REGNUM
);
1570 cfm
= read_register (IA64_CFM_REGNUM
);
1573 else if ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
))
1575 bsp
= read_sigcontext_register (get_next_frame (frame
), IA64_BSP_REGNUM
);
1576 cfm
= read_sigcontext_register (get_next_frame (frame
), IA64_CFM_REGNUM
);
1578 else if (next_frame_is_call_dummy
)
1580 bsp
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame
)),
1581 get_frame_base (get_next_frame (frame
)),
1583 cfm
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame
)),
1584 get_frame_base (get_next_frame (frame
)),
1589 struct frame_info
*frn
= get_next_frame (frame
);
1591 DEPRECATED_FRAME_INIT_SAVED_REGS (frn
);
1593 if (get_frame_saved_regs (frn
)[IA64_CFM_REGNUM
] != 0)
1594 cfm
= read_memory_integer (get_frame_saved_regs (frn
)[IA64_CFM_REGNUM
], 8);
1595 else if (get_next_frame (frn
) && (get_frame_type (get_next_frame (frn
)) == SIGTRAMP_FRAME
))
1596 cfm
= read_sigcontext_register (get_next_frame (frn
), IA64_PFS_REGNUM
);
1597 else if (get_next_frame (frn
)
1598 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frn
)),
1599 get_frame_base (get_next_frame (frn
)),
1600 get_frame_base (get_next_frame (frn
))))
1601 cfm
= deprecated_read_register_dummy (get_frame_pc (get_next_frame (frn
)),
1602 get_frame_base (get_next_frame (frn
)),
1605 cfm
= read_register (IA64_PFS_REGNUM
);
1607 bsp
= get_frame_extra_info (frn
)->bsp
;
1609 get_frame_extra_info (frame
)->cfm
= cfm
;
1610 get_frame_extra_info (frame
)->sof
= cfm
& 0x7f;
1611 get_frame_extra_info (frame
)->sol
= (cfm
>> 7) & 0x7f;
1612 if (get_next_frame (frame
) == 0
1613 || (get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
)
1614 || next_frame_is_call_dummy
)
1615 get_frame_extra_info (frame
)->bsp
=
1616 rse_address_add (bsp
, -get_frame_extra_info (frame
)->sof
);
1618 get_frame_extra_info (frame
)->bsp
=
1619 rse_address_add (bsp
, -get_frame_extra_info (frame
)->sol
);
1621 get_frame_extra_info (frame
)->after_prologue
= 0;
1622 get_frame_extra_info (frame
)->mem_stack_frame_size
= -1; /* Not yet determined */
1623 get_frame_extra_info (frame
)->fp_reg
= 0;
1627 is_float_or_hfa_type_recurse (struct type
*t
, struct type
**etp
)
1629 switch (TYPE_CODE (t
))
1633 return TYPE_LENGTH (*etp
) == TYPE_LENGTH (t
);
1640 case TYPE_CODE_ARRAY
:
1642 is_float_or_hfa_type_recurse (check_typedef (TYPE_TARGET_TYPE (t
)),
1645 case TYPE_CODE_STRUCT
:
1649 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
1650 if (!is_float_or_hfa_type_recurse
1651 (check_typedef (TYPE_FIELD_TYPE (t
, i
)), etp
))
1662 /* Determine if the given type is one of the floating point types or
1663 and HFA (which is a struct, array, or combination thereof whose
1664 bottom-most elements are all of the same floating point type.) */
1666 static struct type
*
1667 is_float_or_hfa_type (struct type
*t
)
1669 struct type
*et
= 0;
1671 return is_float_or_hfa_type_recurse (t
, &et
) ? et
: 0;
1675 /* Return 1 if the alignment of T is such that the next even slot
1676 should be used. Return 0, if the next available slot should
1677 be used. (See section 8.5.1 of the IA-64 Software Conventions
1678 and Runtime manual.) */
1681 slot_alignment_is_next_even (struct type
*t
)
1683 switch (TYPE_CODE (t
))
1687 if (TYPE_LENGTH (t
) > 8)
1691 case TYPE_CODE_ARRAY
:
1693 slot_alignment_is_next_even (check_typedef (TYPE_TARGET_TYPE (t
)));
1694 case TYPE_CODE_STRUCT
:
1698 for (i
= 0; i
< TYPE_NFIELDS (t
); i
++)
1699 if (slot_alignment_is_next_even
1700 (check_typedef (TYPE_FIELD_TYPE (t
, i
))))
1709 /* Attempt to find (and return) the global pointer for the given
1712 This is a rather nasty bit of code searchs for the .dynamic section
1713 in the objfile corresponding to the pc of the function we're trying
1714 to call. Once it finds the addresses at which the .dynamic section
1715 lives in the child process, it scans the Elf64_Dyn entries for a
1716 DT_PLTGOT tag. If it finds one of these, the corresponding
1717 d_un.d_ptr value is the global pointer. */
1720 generic_elf_find_global_pointer (CORE_ADDR faddr
)
1722 struct obj_section
*faddr_sect
;
1724 faddr_sect
= find_pc_section (faddr
);
1725 if (faddr_sect
!= NULL
)
1727 struct obj_section
*osect
;
1729 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
1731 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
1735 if (osect
< faddr_sect
->objfile
->sections_end
)
1740 while (addr
< osect
->endaddr
)
1746 status
= target_read_memory (addr
, buf
, sizeof (buf
));
1749 tag
= extract_signed_integer (buf
, sizeof (buf
));
1751 if (tag
== DT_PLTGOT
)
1753 CORE_ADDR global_pointer
;
1755 status
= target_read_memory (addr
+ 8, buf
, sizeof (buf
));
1758 global_pointer
= extract_unsigned_integer (buf
, sizeof (buf
));
1761 return global_pointer
;
1774 /* Given a function's address, attempt to find (and return) the
1775 corresponding (canonical) function descriptor. Return 0 if
1778 find_extant_func_descr (CORE_ADDR faddr
)
1780 struct obj_section
*faddr_sect
;
1782 /* Return early if faddr is already a function descriptor */
1783 faddr_sect
= find_pc_section (faddr
);
1784 if (faddr_sect
&& strcmp (faddr_sect
->the_bfd_section
->name
, ".opd") == 0)
1787 if (faddr_sect
!= NULL
)
1789 struct obj_section
*osect
;
1790 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
1792 if (strcmp (osect
->the_bfd_section
->name
, ".opd") == 0)
1796 if (osect
< faddr_sect
->objfile
->sections_end
)
1801 while (addr
< osect
->endaddr
)
1807 status
= target_read_memory (addr
, buf
, sizeof (buf
));
1810 faddr2
= extract_signed_integer (buf
, sizeof (buf
));
1812 if (faddr
== faddr2
)
1822 /* Attempt to find a function descriptor corresponding to the
1823 given address. If none is found, construct one on the
1824 stack using the address at fdaptr */
1827 find_func_descr (CORE_ADDR faddr
, CORE_ADDR
*fdaptr
)
1831 fdesc
= find_extant_func_descr (faddr
);
1835 CORE_ADDR global_pointer
;
1841 global_pointer
= FIND_GLOBAL_POINTER (faddr
);
1843 if (global_pointer
== 0)
1844 global_pointer
= read_register (IA64_GR1_REGNUM
);
1846 store_unsigned_integer (buf
, 8, faddr
);
1847 store_unsigned_integer (buf
+ 8, 8, global_pointer
);
1849 write_memory (fdesc
, buf
, 16);
1856 ia64_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1857 int struct_return
, CORE_ADDR struct_addr
)
1863 int nslots
, rseslots
, memslots
, slotnum
, nfuncargs
;
1865 CORE_ADDR bsp
, cfm
, pfs
, new_bsp
, funcdescaddr
;
1869 /* Count the number of slots needed for the arguments */
1870 for (argno
= 0; argno
< nargs
; argno
++)
1873 type
= check_typedef (VALUE_TYPE (arg
));
1874 len
= TYPE_LENGTH (type
);
1876 if ((nslots
& 1) && slot_alignment_is_next_even (type
))
1879 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1882 nslots
+= (len
+ 7) / 8;
1885 /* Divvy up the slots between the RSE and the memory stack */
1886 rseslots
= (nslots
> 8) ? 8 : nslots
;
1887 memslots
= nslots
- rseslots
;
1889 /* Allocate a new RSE frame */
1890 cfm
= read_register (IA64_CFM_REGNUM
);
1892 bsp
= read_register (IA64_BSP_REGNUM
);
1893 bsp
= rse_address_add (bsp
, cfm
& 0x7f);
1894 new_bsp
= rse_address_add (bsp
, rseslots
);
1895 write_register (IA64_BSP_REGNUM
, new_bsp
);
1897 pfs
= read_register (IA64_PFS_REGNUM
);
1898 pfs
&= 0xc000000000000000LL
;
1899 pfs
|= (cfm
& 0xffffffffffffLL
);
1900 write_register (IA64_PFS_REGNUM
, pfs
);
1902 cfm
&= 0xc000000000000000LL
;
1904 write_register (IA64_CFM_REGNUM
, cfm
);
1906 /* We will attempt to find function descriptors in the .opd segment,
1907 but if we can't we'll construct them ourselves. That being the
1908 case, we'll need to reserve space on the stack for them. */
1909 funcdescaddr
= sp
- nfuncargs
* 16;
1910 funcdescaddr
&= ~0xfLL
;
1912 /* Adjust the stack pointer to it's new value. The calling conventions
1913 require us to have 16 bytes of scratch, plus whatever space is
1914 necessary for the memory slots and our function descriptors */
1915 sp
= sp
- 16 - (memslots
+ nfuncargs
) * 8;
1916 sp
&= ~0xfLL
; /* Maintain 16 byte alignment */
1918 /* Place the arguments where they belong. The arguments will be
1919 either placed in the RSE backing store or on the memory stack.
1920 In addition, floating point arguments or HFAs are placed in
1921 floating point registers. */
1923 floatreg
= IA64_FR8_REGNUM
;
1924 for (argno
= 0; argno
< nargs
; argno
++)
1926 struct type
*float_elt_type
;
1929 type
= check_typedef (VALUE_TYPE (arg
));
1930 len
= TYPE_LENGTH (type
);
1932 /* Special handling for function parameters */
1934 && TYPE_CODE (type
) == TYPE_CODE_PTR
1935 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1939 store_unsigned_integer (val_buf
, 8,
1940 find_func_descr (extract_unsigned_integer (VALUE_CONTENTS (arg
), 8),
1942 if (slotnum
< rseslots
)
1943 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
1945 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
1952 /* Skip odd slot if necessary... */
1953 if ((slotnum
& 1) && slot_alignment_is_next_even (type
))
1961 memset (val_buf
, 0, 8);
1962 memcpy (val_buf
, VALUE_CONTENTS (arg
) + argoffset
, (len
> 8) ? 8 : len
);
1964 if (slotnum
< rseslots
)
1965 write_memory (rse_address_add (bsp
, slotnum
), val_buf
, 8);
1967 write_memory (sp
+ 16 + 8 * (slotnum
- rseslots
), val_buf
, 8);
1974 /* Handle floating point types (including HFAs) */
1975 float_elt_type
= is_float_or_hfa_type (type
);
1976 if (float_elt_type
!= NULL
)
1979 len
= TYPE_LENGTH (type
);
1980 while (len
> 0 && floatreg
< IA64_FR16_REGNUM
)
1982 ia64_register_convert_to_raw (
1985 VALUE_CONTENTS (arg
) + argoffset
,
1986 &deprecated_registers
[REGISTER_BYTE (floatreg
)]);
1988 argoffset
+= TYPE_LENGTH (float_elt_type
);
1989 len
-= TYPE_LENGTH (float_elt_type
);
1994 /* Store the struct return value in r8 if necessary. */
1997 store_unsigned_integer (&deprecated_registers
[REGISTER_BYTE (IA64_GR8_REGNUM
)],
1998 REGISTER_RAW_SIZE (IA64_GR8_REGNUM
),
2002 /* Sync gdb's idea of what the registers are with the target. */
2003 target_store_registers (-1);
2005 /* FIXME: This doesn't belong here! Instead,
2006 DEPRECATED_SAVE_DUMMY_FRAME_TOS needs to be defined to call
2007 generic_save_dummy_frame_tos(). But at the time of this writing,
2008 DEPRECATED_SAVE_DUMMY_FRAME_TOS wasn't gdbarch'd, so I chose to
2009 put this call here instead of using the old mechanisms. Once
2010 DEPRECATED_SAVE_DUMMY_FRAME_TOS is gdbarch'd, all we need to do
2013 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
2015 to ia64_gdbarch_init() and remove the line below. */
2016 generic_save_dummy_frame_tos (sp
);
2022 ia64_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
2024 CORE_ADDR global_pointer
= FIND_GLOBAL_POINTER (pc
);
2026 if (global_pointer
!= 0)
2027 write_register (IA64_GR1_REGNUM
, global_pointer
);
2029 write_register (IA64_BR0_REGNUM
, CALL_DUMMY_ADDRESS ());
2034 ia64_store_return_value (struct type
*type
, char *valbuf
)
2036 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
2038 ia64_register_convert_to_raw (type
, IA64_FR8_REGNUM
, valbuf
,
2039 &deprecated_registers
[REGISTER_BYTE (IA64_FR8_REGNUM
)]);
2040 target_store_registers (IA64_FR8_REGNUM
);
2043 deprecated_write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM
),
2044 valbuf
, TYPE_LENGTH (type
));
2048 ia64_pop_frame (void)
2050 generic_pop_current_frame (ia64_pop_frame_regular
);
2054 ia64_pop_frame_regular (struct frame_info
*frame
)
2057 CORE_ADDR bsp
, cfm
, pfs
;
2059 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
2061 for (regno
= 0; regno
< ia64_num_regs
; regno
++)
2063 if (get_frame_saved_regs (frame
)[regno
]
2064 && (!(IA64_GR32_REGNUM
<= regno
&& regno
<= IA64_GR127_REGNUM
))
2065 && regno
!= pc_regnum
2066 && regno
!= sp_regnum
2067 && regno
!= IA64_PFS_REGNUM
2068 && regno
!= IA64_CFM_REGNUM
2069 && regno
!= IA64_BSP_REGNUM
2070 && regno
!= IA64_BSPSTORE_REGNUM
)
2072 write_register (regno
,
2073 read_memory_integer (get_frame_saved_regs (frame
)[regno
],
2074 REGISTER_RAW_SIZE (regno
)));
2078 write_register (sp_regnum
, DEPRECATED_FRAME_CHAIN (frame
));
2079 write_pc (DEPRECATED_FRAME_SAVED_PC (frame
));
2081 cfm
= read_register (IA64_CFM_REGNUM
);
2083 if (get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
])
2085 pfs
= read_memory_integer (get_frame_saved_regs (frame
)[IA64_PFS_REGNUM
],
2086 REGISTER_RAW_SIZE (IA64_PFS_REGNUM
));
2089 pfs
= read_register (IA64_PFS_REGNUM
);
2091 /* Compute the new bsp by *adding* the difference between the
2092 size of the frame and the size of the locals (both wrt the
2093 frame that we're going back to). This seems kind of strange,
2094 especially since it seems like we ought to be subtracting the
2095 size of the locals... and we should; but the Linux kernel
2096 wants bsp to be set at the end of all used registers. It's
2097 likely that this code will need to be revised to accomodate
2098 other operating systems. */
2099 bsp
= rse_address_add (get_frame_extra_info (frame
)->bsp
,
2100 (pfs
& 0x7f) - ((pfs
>> 7) & 0x7f));
2101 write_register (IA64_BSP_REGNUM
, bsp
);
2103 /* FIXME: What becomes of the epilog count in the PFS? */
2104 cfm
= (cfm
& ~0xffffffffffffLL
) | (pfs
& 0xffffffffffffLL
);
2105 write_register (IA64_CFM_REGNUM
, cfm
);
2107 flush_cached_frames ();
2111 ia64_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
2112 struct regcache
*regcache
,
2113 CORE_ADDR memaddr
, int nr_bytes
,
2114 CORE_ADDR
*targ_addr
, int *targ_len
)
2116 *targ_addr
= memaddr
;
2117 *targ_len
= nr_bytes
;
2121 process_note_abi_tag_sections (bfd
*abfd
, asection
*sect
, void *obj
)
2123 int *os_ident_ptr
= obj
;
2125 unsigned int sectsize
;
2127 name
= bfd_get_section_name (abfd
, sect
);
2128 sectsize
= bfd_section_size (abfd
, sect
);
2129 if (strcmp (name
, ".note.ABI-tag") == 0 && sectsize
> 0)
2131 unsigned int name_length
, data_length
, note_type
;
2132 char *note
= alloca (sectsize
);
2134 bfd_get_section_contents (abfd
, sect
, note
,
2135 (file_ptr
) 0, (bfd_size_type
) sectsize
);
2137 name_length
= bfd_h_get_32 (abfd
, note
);
2138 data_length
= bfd_h_get_32 (abfd
, note
+ 4);
2139 note_type
= bfd_h_get_32 (abfd
, note
+ 8);
2141 if (name_length
== 4 && data_length
== 16 && note_type
== 1
2142 && strcmp (note
+ 12, "GNU") == 0)
2144 int os_number
= bfd_h_get_32 (abfd
, note
+ 16);
2146 /* The case numbers are from abi-tags in glibc */
2150 *os_ident_ptr
= ELFOSABI_LINUX
;
2153 *os_ident_ptr
= ELFOSABI_HURD
;
2156 *os_ident_ptr
= ELFOSABI_SOLARIS
;
2159 internal_error (__FILE__
, __LINE__
,
2160 "process_note_abi_sections: unknown OS number %d", os_number
);
2167 static struct gdbarch
*
2168 ia64_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2170 struct gdbarch
*gdbarch
;
2171 struct gdbarch_tdep
*tdep
;
2174 if (info
.abfd
!= NULL
2175 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
2177 os_ident
= elf_elfheader (info
.abfd
)->e_ident
[EI_OSABI
];
2179 /* If os_ident is 0, it is not necessarily the case that we're
2180 on a SYSV system. (ELFOSABI_NONE is defined to be 0.)
2181 GNU/Linux uses a note section to record OS/ABI info, but
2182 leaves e_ident[EI_OSABI] zero. So we have to check for note
2186 bfd_map_over_sections (info
.abfd
,
2187 process_note_abi_tag_sections
,
2194 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2196 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
2198 tdep
= gdbarch_tdep (arches
->gdbarch
);
2199 if (tdep
&&tdep
->os_ident
== os_ident
)
2200 return arches
->gdbarch
;
2203 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
2204 gdbarch
= gdbarch_alloc (&info
, tdep
);
2205 tdep
->os_ident
= os_ident
;
2207 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2208 ready to unwind the PC first (see frame.c:get_prev_frame()). */
2209 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
2211 /* Set the method of obtaining the sigcontext addresses at which
2212 registers are saved. The method of checking to see if
2213 native_find_global_pointer is nonzero to indicate that we're
2214 on AIX is kind of hokey, but I can't think of a better way
2216 if (os_ident
== ELFOSABI_LINUX
)
2217 tdep
->sigcontext_register_address
= ia64_linux_sigcontext_register_address
;
2218 else if (native_find_global_pointer
!= 0)
2219 tdep
->sigcontext_register_address
= ia64_aix_sigcontext_register_address
;
2221 tdep
->sigcontext_register_address
= 0;
2223 /* We know that GNU/Linux won't have to resort to the
2224 native_find_global_pointer hackery. But that's the only one we
2225 know about so far, so if native_find_global_pointer is set to
2226 something non-zero, then use it. Otherwise fall back to using
2227 generic_elf_find_global_pointer. This arrangement should (in
2228 theory) allow us to cross debug GNU/Linux binaries from an AIX
2230 if (os_ident
== ELFOSABI_LINUX
)
2231 tdep
->find_global_pointer
= generic_elf_find_global_pointer
;
2232 else if (native_find_global_pointer
!= 0)
2233 tdep
->find_global_pointer
= native_find_global_pointer
;
2235 tdep
->find_global_pointer
= generic_elf_find_global_pointer
;
2237 set_gdbarch_short_bit (gdbarch
, 16);
2238 set_gdbarch_int_bit (gdbarch
, 32);
2239 set_gdbarch_long_bit (gdbarch
, 64);
2240 set_gdbarch_long_long_bit (gdbarch
, 64);
2241 set_gdbarch_float_bit (gdbarch
, 32);
2242 set_gdbarch_double_bit (gdbarch
, 64);
2243 set_gdbarch_long_double_bit (gdbarch
, 128);
2244 set_gdbarch_ptr_bit (gdbarch
, 64);
2246 set_gdbarch_num_regs (gdbarch
, ia64_num_regs
);
2247 set_gdbarch_sp_regnum (gdbarch
, sp_regnum
);
2248 set_gdbarch_deprecated_fp_regnum (gdbarch
, fp_regnum
);
2249 set_gdbarch_pc_regnum (gdbarch
, pc_regnum
);
2250 set_gdbarch_fp0_regnum (gdbarch
, IA64_FR0_REGNUM
);
2252 set_gdbarch_register_name (gdbarch
, ia64_register_name
);
2253 set_gdbarch_deprecated_register_size (gdbarch
, 8);
2254 set_gdbarch_deprecated_register_bytes (gdbarch
, ia64_num_regs
* 8 + 128*8);
2255 set_gdbarch_deprecated_register_byte (gdbarch
, ia64_register_byte
);
2256 set_gdbarch_deprecated_register_raw_size (gdbarch
, ia64_register_raw_size
);
2257 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 16);
2258 set_gdbarch_deprecated_register_virtual_size (gdbarch
, ia64_register_virtual_size
);
2259 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 16);
2260 set_gdbarch_deprecated_register_virtual_type (gdbarch
, ia64_register_virtual_type
);
2262 set_gdbarch_skip_prologue (gdbarch
, ia64_skip_prologue
);
2264 set_gdbarch_frameless_function_invocation (gdbarch
, ia64_frameless_function_invocation
);
2266 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, ia64_saved_pc_after_call
);
2268 set_gdbarch_deprecated_frame_chain (gdbarch
, ia64_frame_chain
);
2269 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, ia64_frame_saved_pc
);
2271 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, ia64_frame_init_saved_regs
);
2272 set_gdbarch_deprecated_get_saved_register (gdbarch
, ia64_get_saved_register
);
2274 set_gdbarch_deprecated_register_convertible (gdbarch
, ia64_register_convertible
);
2275 set_gdbarch_deprecated_register_convert_to_virtual (gdbarch
, ia64_register_convert_to_virtual
);
2276 set_gdbarch_deprecated_register_convert_to_raw (gdbarch
, ia64_register_convert_to_raw
);
2278 set_gdbarch_use_struct_convention (gdbarch
, ia64_use_struct_convention
);
2279 set_gdbarch_deprecated_extract_return_value (gdbarch
, ia64_extract_return_value
);
2281 set_gdbarch_deprecated_store_struct_return (gdbarch
, ia64_store_struct_return
);
2282 set_gdbarch_deprecated_store_return_value (gdbarch
, ia64_store_return_value
);
2283 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, ia64_extract_struct_value_address
);
2285 set_gdbarch_memory_insert_breakpoint (gdbarch
, ia64_memory_insert_breakpoint
);
2286 set_gdbarch_memory_remove_breakpoint (gdbarch
, ia64_memory_remove_breakpoint
);
2287 set_gdbarch_breakpoint_from_pc (gdbarch
, ia64_breakpoint_from_pc
);
2288 set_gdbarch_read_pc (gdbarch
, ia64_read_pc
);
2289 set_gdbarch_write_pc (gdbarch
, ia64_write_pc
);
2291 /* Settings for calling functions in the inferior. */
2292 set_gdbarch_deprecated_push_arguments (gdbarch
, ia64_push_arguments
);
2293 set_gdbarch_deprecated_push_return_address (gdbarch
, ia64_push_return_address
);
2294 set_gdbarch_deprecated_pop_frame (gdbarch
, ia64_pop_frame
);
2296 set_gdbarch_deprecated_call_dummy_words (gdbarch
, ia64_call_dummy_words
);
2297 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (ia64_call_dummy_words
));
2298 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, ia64_init_extra_frame_info
);
2299 set_gdbarch_frame_args_address (gdbarch
, ia64_frame_args_address
);
2300 set_gdbarch_frame_locals_address (gdbarch
, ia64_frame_locals_address
);
2302 /* We won't necessarily have a frame pointer and even if we do, it
2303 winds up being extraordinarly messy when attempting to find the
2304 frame chain. So for the purposes of creating frames (which is
2305 all deprecated_read_fp() is used for), simply use the stack
2306 pointer value instead. */
2307 set_gdbarch_deprecated_target_read_fp (gdbarch
, ia64_read_fp
);
2309 /* Settings that should be unnecessary. */
2310 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2312 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
2314 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
2315 set_gdbarch_function_start_offset (gdbarch
, 0);
2316 set_gdbarch_frame_args_skip (gdbarch
, 0);
2318 set_gdbarch_remote_translate_xfer_address (
2319 gdbarch
, ia64_remote_translate_xfer_address
);
2324 extern initialize_file_ftype _initialize_ia64_tdep
; /* -Wmissing-prototypes */
2327 _initialize_ia64_tdep (void)
2329 register_gdbarch_init (bfd_arch_ia64
, ia64_gdbarch_init
);
2331 deprecated_tm_print_insn
= print_insn_ia64
;
2332 deprecated_tm_print_insn_info
.bytes_per_line
= SLOT_MULTIPLIER
;