| blob | 6d537c4c8d366a84f6bd515d6fec5d46bfafc747 |
1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
3 Copyright (C) 1999-2023 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 3 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, see <http://www.gnu.org/licenses/>. */
42 #ifdef HAVE_LIBUNWIND_IA64_H
46 /* Note: KERNEL_START is supposed to be an address which is not going
47 to ever contain any valid unwind info. For ia64 linux, the choice
48 of 0xc000000000000000 is fairly safe since that's uncached space.
50 We use KERNEL_START as follows: after obtaining the kernel's
51 unwind table via getunwind(), we project its unwind data into
52 address-range KERNEL_START-(KERNEL_START+ktab_size) and then
53 when ia64_access_mem() sees a memory access to this
54 address-range, we redirect it to ktab instead.
56 None of this hackery is needed with a modern kernel/libcs
57 which uses the kernel virtual DSO to provide access to the
58 kernel's unwind info. In that case, ktab_size remains 0 and
59 hence the value of KERNEL_START doesn't matter. */
61 #define KERNEL_START 0xc000000000000000ULL
64 struct ia64_table_entry
65 {
69 };
74 #endif
76 /* An enumeration of the different IA-64 instruction types. */
78 enum ia64_instruction_type
79 {
87 undefined /* undefined or reserved */
88 };
90 /* We represent IA-64 PC addresses as the value of the instruction
91 pointer or'd with some bit combination in the low nibble which
92 represents the slot number in the bundle addressed by the
93 instruction pointer. The problem is that the Linux kernel
94 multiplies its slot numbers (for exceptions) by one while the
95 disassembler multiplies its slot numbers by 6. In addition, I've
96 heard it said that the simulator uses 1 as the multiplier.
98 I've fixed the disassembler so that the bytes_per_line field will
99 be the slot multiplier. If bytes_per_line comes in as zero, it
100 is set to six (which is how it was set up initially). -- objdump
101 displays pretty disassembly dumps with this value. For our purposes,
102 we'll set bytes_per_line to SLOT_MULTIPLIER. This is okay since we
103 never want to also display the raw bytes the way objdump does. */
105 #define SLOT_MULTIPLIER 1
107 /* Length in bytes of an instruction bundle. */
109 #define BUNDLE_LEN 16
111 /* See the saved memory layout comment for ia64_memory_insert_breakpoint. */
113 #if BREAKPOINT_MAX < BUNDLE_LEN - 2
115 #endif
125 CORE_ADDR faddr);
127 #define NUM_IA64_RAW_REGS 462
129 /* Big enough to hold a FP register in bytes. */
130 #define IA64_FP_REGISTER_SIZE 16
134 /* NOTE: we treat the register stack registers r32-r127 as
135 pseudo-registers because they may not be accessible via the ptrace
136 register get/set interfaces. */
144 /* Array of register names; There should be ia64_num_regs strings in
145 the initializer. */
254 };
256 struct ia64_frame_cache
257 {
268 cfm value). */
269 CORE_ADDR after_prologue;
270 /* Address of first instruction after the last
271 prologue instruction; Note that there may
272 be instructions from the function's body
273 intermingled with the prologue. */
275 /* Size of the memory stack frame (may be zero),
276 or -1 if it has not been determined yet. */
278 for this frame. 0 if no register is being used
279 as the frame pointer. */
281 /* Saved registers. */
284 };
286 static int
288 {
290 }
293 {
296 };
299 {
302 };
305 {
307 &floatformat_ia64_ext_little
308 };
312 {
316 {
318 tdep->ia64_ext_type
320 floatformats_ia64_ext);
321 }
324 }
326 static int
329 {
347 }
351 {
353 }
357 {
360 else
362 }
364 static int
366 {
370 }
373 /* Extract ``len'' bits from an instruction bundle starting at
374 bit ``from''. */
376 static long long
378 {
395 {
398 }
401 {
405 }
408 }
410 /* Replace the specified bits in an instruction bundle. */
412 static void
414 {
422 {
431 }
432 else
433 {
442 {
446 }
449 {
455 }
456 }
457 }
459 /* Return the contents of slot N (for N = 0, 1, or 2) in
460 and instruction bundle. */
462 static long long
464 {
466 }
468 /* Store an instruction in an instruction bundle. */
470 static void
472 {
474 }
477 {
510 };
512 /* Fetch and (partially) decode an instruction at ADDR and return the
513 address of the next instruction to fetch. */
515 static CORE_ADDR
517 {
523 /* Warn about slot numbers greater than 2. We used to generate
524 an error here on the assumption that the user entered an invalid
525 address. But, sometimes GDB itself requests an invalid address.
526 This can (easily) happen when execution stops in a function for
527 which there are no symbols. The prologue scanner will attempt to
528 find the beginning of the function - if the nearest symbol
529 happens to not be aligned on a bundle boundary (16 bytes), the
530 resulting starting address will cause GDB to think that the slot
531 number is too large.
533 So we warn about it and set the slot number to zero. It is
534 not necessarily a fatal condition, particularly if debugging
535 at the assembly language level. */
537 {
541 }
556 else
560 }
562 /* There are 5 different break instructions (break.i, break.b,
563 break.m, break.f, and break.x), but they all have the same
564 encoding. (The five bit template in the low five bits of the
565 instruction bundle distinguishes one from another.)
567 The runtime architecture manual specifies that break instructions
568 used for debugging purposes must have the upper two bits of the 21
569 bit immediate set to a 0 and a 1 respectively. A breakpoint
570 instruction encodes the most significant bit of its 21 bit
571 immediate at bit 36 of the 41 bit instruction. The penultimate msb
572 is at bit 25 which leads to the pattern below.
574 Originally, I had this set up to do, e.g, a "break.i 0x80000" But
575 it turns out that 0x80000 was used as the syscall break in the early
576 simulators. So I changed the pattern slightly to do "break.i 0x080001"
577 instead. But that didn't work either (I later found out that this
578 pattern was used by the simulator that I was using.) So I ended up
579 using the pattern seen below.
581 SHADOW_CONTENTS has byte-based addressing (PLACED_ADDRESS and SHADOW_LEN)
582 while we need bit-based addressing as the instructions length is 41 bits and
583 we must not modify/corrupt the adjacent slots in the same bundle.
584 Fortunately we may store larger memory incl. the adjacent bits with the
585 original memory content (not the possibly already stored breakpoints there).
586 We need to be careful in ia64_memory_remove_breakpoint to always restore
587 only the specific bits of this instruction ignoring any adjacent stored
588 bits.
590 We use the original addressing with the low nibble in the range <0..2> which
591 gets incorrectly interpreted by generic non-ia64 breakpoint_restore_shadows
592 as the direct byte offset of SHADOW_CONTENTS. We store whole BUNDLE_LEN
593 bytes just without these two possibly skipped bytes to not to exceed to the
594 next bundle.
596 If we would like to store the whole bundle to SHADOW_CONTENTS we would have
597 to store already the base address (`address & ~0x0f') into PLACED_ADDRESS.
598 In such case there is no other place where to store
599 SLOTNUM (`adress & 0x0f', value in the range <0..2>). We need to know
600 SLOTNUM in ia64_memory_remove_breakpoint.
602 There is one special case where we need to be extra careful:
603 L-X instructions, which are instructions that occupy 2 slots
604 (The L part is always in slot 1, and the X part is always in
605 slot 2). We must refuse to insert breakpoints for an address
606 that points at slot 2 of a bundle where an L-X instruction is
607 present, since there is logically no instruction at that address.
608 However, to make things more interesting, the opcode of L-X
609 instructions is located in slot 2. This means that, to insert
610 a breakpoint at an address that points to slot 1, we actually
611 need to write the breakpoint in slot 2! Slot 1 is actually
612 the extended operand, so writing the breakpoint there would not
613 have the desired effect. Another side-effect of this issue
614 is that we need to make sure that the shadow contents buffer
615 does save byte 15 of our instruction bundle (this is the tail
616 end of slot 2, which wouldn't be saved if we were to insert
617 the breakpoint in slot 1).
619 ia64 16-byte bundle layout:
620 | 5 bits | slot 0 with 41 bits | slot 1 with 41 bits | slot 2 with 41 bits |
622 The current addressing used by the code below:
623 original PC placed_address placed_size required covered
624 == bp_tgt->shadow_len reqd \subset covered
625 0xABCDE0 0xABCDE0 0x10 <0x0...0x5> <0x0..0xF>
626 0xABCDE1 0xABCDE1 0xF <0x5...0xA> <0x1..0xF>
627 0xABCDE2 0xABCDE2 0xE <0xA...0xF> <0x2..0xF>
629 L-X instructions are treated a little specially, as explained above:
630 0xABCDE1 0xABCDE1 0xF <0xA...0xF> <0x1..0xF>
632 `objdump -d' and some other tools show a bit unjustified offsets:
633 original PC byte where starts the instruction objdump offset
634 0xABCDE0 0xABCDE0 0xABCDE0
635 0xABCDE1 0xABCDE5 0xABCDE6
636 0xABCDE2 0xABCDEA 0xABCDEC
637 */
639 #define IA64_BREAKPOINT 0x00003333300LL
641 static int
644 {
657 /* Enable the automatic memory restoration from breakpoints while
658 we read our instruction bundle for the purpose of SHADOW_CONTENTS.
659 Otherwise, we could possibly store into the shadow parts of the adjacent
660 placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real
661 breakpoint instruction bits region. */
662 scoped_restore restore_memory_0
668 /* SHADOW_SLOTNUM saves the original slot number as expected by the caller
669 for addressing the SHADOW_CONTENTS placement. */
672 /* Always cover the last byte of the bundle in case we are inserting
673 a breakpoint on an L-X instruction. */
678 {
679 /* X unit types can only be used in slot 2, and are actually
680 part of a 2-slot L-X instruction. We cannot break at this
681 address, as this is the second half of an instruction that
682 lives in slot 1 of that bundle. */
685 }
687 {
688 /* L unit types can only be used in slot 1. But the associated
689 opcode for that instruction is in slot 2, so bump the slot number
690 accordingly. */
693 }
695 /* Store the whole bundle, except for the initial skipped bytes by the slot
696 number interpreted as bytes offset in PLACED_ADDRESS. */
700 /* Re-read the same bundle as above except that, this time, read it in order
701 to compute the new bundle inside which we will be inserting the
702 breakpoint. Therefore, disable the automatic memory restoration from
703 breakpoints while we read our instruction bundle. Otherwise, the general
704 restoration mechanism kicks in and we would possibly remove parts of the
705 adjacent placed breakpoints. It is due to our SHADOW_CONTENTS overlapping
706 the real breakpoint instruction bits region. */
707 scoped_restore restore_memory_1
713 /* Breakpoints already present in the code will get detected and not get
714 reinserted by bp_loc_is_permanent. Multiple breakpoints at the same
715 location cannot induce the internal error as they are optimized into
716 a single instance by update_global_location_list. */
727 }
729 static int
732 {
742 /* Disable the automatic memory restoration from breakpoints while
743 we read our instruction bundle. Otherwise, the general restoration
744 mechanism kicks in and we would possibly remove parts of the adjacent
745 placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real
746 breakpoint instruction bits region. */
747 scoped_restore restore_memory_1
753 /* SHADOW_SLOTNUM saves the original slot number as expected by the caller
754 for addressing the SHADOW_CONTENTS placement. */
759 {
760 /* X unit types can only be used in slot 2, and are actually
761 part of a 2-slot L-X instruction. We refuse to insert
762 breakpoints at this address, so there should be no reason
763 for us attempting to remove one there, except if the program's
764 code somehow got modified in memory. */
770 }
772 {
773 /* L unit types can only be used in slot 1. But the breakpoint
774 was actually saved using slot 2, so update the slot number
775 accordingly. */
778 }
784 {
789 }
791 /* Extract the original saved instruction from SLOTNUM normalizing its
792 bit-shift for INSTR_SAVED. */
798 /* In BUNDLE_MEM, be careful to modify only the bits belonging to SLOTNUM
799 and not any of the other ones that are stored in SHADOW_CONTENTS. */
804 }
806 /* Implement the breakpoint_kind_from_pc gdbarch method. */
808 static int
810 {
811 /* A place holder of gdbarch method breakpoint_kind_from_pc. */
813 }
815 /* As gdbarch_breakpoint_from_pc ranges have byte granularity and ia64
816 instruction slots ranges are bit-granular (41 bits) we have to provide an
817 extended range as described for ia64_memory_insert_breakpoint. We also take
818 care of preserving the `break' instruction 21-bit (or 62-bit) parameter to
819 make a match for permanent breakpoints. */
824 {
837 /* Enable the automatic memory restoration from breakpoints while
838 we read our instruction bundle to match bp_loc_is_permanent. */
839 {
840 scoped_restore restore_memory_0
843 }
845 /* The memory might be unreachable. This can happen, for instance,
846 when the user inserts a breakpoint at an invalid address. */
850 /* SHADOW_SLOTNUM saves the original slot number as expected by the caller
851 for addressing the SHADOW_CONTENTS placement. */
854 /* Cover always the last byte of the bundle for the L-X slot case. */
857 /* Check for L type instruction in slot 1, if present then bump up the slot
858 number to the slot 2. */
861 {
864 }
866 {
869 }
871 /* A break instruction has its all its opcode bits cleared except for
872 the parameter value. For L+X slot pair we are at the X slot (slot 2) so
873 we should not touch the L slot - the upper 41 bits of the parameter. */
879 }
881 static CORE_ADDR
883 {
892 }
894 void
896 {
898 ULONGEST psr_value;
908 }
910 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
912 /* Returns the address of the slot that's NSLOTS slots away from
913 the address ADDR. NSLOTS may be positive or negative. */
914 static CORE_ADDR
916 {
917 CORE_ADDR new_addr;
930 }
932 static enum register_status
935 {
940 {
941 #ifdef HAVE_LIBUNWIND_IA64_H
942 /* First try and use the libunwind special reg accessor,
943 otherwise fallback to standard logic. */
946 #endif
947 {
948 /* The fallback position is to assume that r32-r127 are
949 found sequentially in memory starting at $bof. This
950 isn't always true, but without libunwind, this is the
951 best we can do. */
952 ULONGEST cfm;
953 ULONGEST bsp;
954 CORE_ADDR reg;
964 /* The bsp points at the end of the register frame so we
965 subtract the size of frame from it to get start of
966 register frame. */
970 {
975 }
976 else
979 }
980 }
982 {
983 ULONGEST unatN_val;
984 ULONGEST unat;
992 }
994 {
996 ULONGEST bsp;
997 ULONGEST cfm;
1008 /* The bsp points at the end of the register frame so we
1009 subtract the size of frame from it to get start of register frame. */
1016 {
1017 /* Compute address of nat collection bits. */
1019 ULONGEST nat_collection;
1021 /* If our nat collection address is bigger than bsp, we have to get
1022 the nat collection from rnat. Otherwise, we fetch the nat
1023 collection from the computed address. */
1026 else
1030 }
1034 }
1036 {
1037 /* A virtual register frame start is provided for user convenience.
1038 It can be calculated as the bsp - sof (sizeof frame). */
1040 ULONGEST cfm;
1049 /* The bsp points at the end of the register frame so we
1050 subtract the size of frame from it to get beginning of frame. */
1054 }
1056 {
1057 ULONGEST pr;
1058 ULONGEST cfm;
1059 ULONGEST prN_val;
1069 {
1070 /* Fetch predicate register rename base from current frame
1071 marker for this frame. */
1074 /* Adjust the register number to account for register rotation. */
1075 regnum = VP16_REGNUM
1077 }
1081 }
1082 else
1086 }
1088 static void
1091 {
1095 {
1096 ULONGEST bsp;
1097 ULONGEST cfm;
1104 {
1107 }
1108 }
1110 {
1114 regnum),
1115 byte_order);
1122 }
1124 {
1125 ULONGEST natN_val;
1126 ULONGEST bsp;
1127 ULONGEST cfm;
1132 /* The bsp points at the end of the register frame so we
1133 subtract the size of frame from it to get start of register frame. */
1140 regnum),
1141 byte_order);
1144 {
1145 /* Compute address of nat collection bits. */
1147 CORE_ADDR nat_collection;
1150 /* If our nat collection address is bigger than bsp, we have to get
1151 the nat collection from rnat. Otherwise, we fetch the nat
1152 collection from the computed address. */
1154 {
1156 IA64_RNAT_REGNUM,
1160 else
1163 nat_collection);
1164 }
1165 else
1166 {
1171 else
1176 }
1177 }
1178 }
1180 {
1181 ULONGEST pr;
1182 ULONGEST cfm;
1183 ULONGEST prN_val;
1184 ULONGEST prN_mask;
1190 {
1191 /* Fetch predicate register rename base from current frame
1192 marker for this frame. */
1195 /* Adjust the register number to account for register rotation. */
1196 regnum = VP16_REGNUM
1198 }
1200 byte_order);
1207 }
1208 }
1210 /* The ia64 needs to convert between various ieee floating-point formats
1211 and the special ia64 floating point register format. */
1213 static int
1215 {
1219 }
1221 static int
1225 {
1229 /* Convert to TYPE. */
1233 regnum)),
1240 }
1242 static void
1245 {
1250 }
1253 /* Limit the number of skipped non-prologue instructions since examining
1254 of the prologue is expensive. */
1257 /* Given PC representing the starting address of a function, and
1258 LIM_PC which is the (sloppy) limit to which to scan when looking
1259 for a prologue, attempt to further refine this limit by using
1260 the line data in the symbol table. If successful, a better guess
1261 on where the prologue ends is returned, otherwise the previous
1262 value of lim_pc is returned. TRUST_LIMIT is a pointer to a flag
1263 which will be set to indicate whether the returned limit may be
1264 used with no further scanning in the event that the function is
1265 frameless. */
1267 /* FIXME: cagney/2004-02-14: This function and logic have largely been
1268 superseded by skip_prologue_using_sal. */
1270 static CORE_ADDR
1272 {
1275 CORE_ADDR end_pc;
1277 /* The prologue can not possibly go past the function end itself,
1278 so we can already adjust LIM_PC accordingly. */
1282 /* Start off not trusting the limit. */
1287 {
1291 /* Handle the case in which compiler's optimizer/scheduler
1292 has moved instructions into the prologue. We scan ahead
1293 in the function looking for address ranges whose corresponding
1294 line number is less than or equal to the first one that we
1295 found for the function. (It can be less than when the
1296 scheduler puts a body instruction before the first prologue
1297 instruction.) */
1300 i--)
1301 {
1309 {
1311 }
1313 }
1316 {
1320 }
1321 }
1323 }
1325 #define isScratch(_regnum_) ((_regnum_) == 2 || (_regnum_) == 3 \
1326 || (8 <= (_regnum_) && (_regnum_) <= 11) \
1327 || (14 <= (_regnum_) && (_regnum_) <= 31))
1328 #define imm9(_instr_) \
1329 ( ((((_instr_) & 0x01000000000LL) ? -1 : 0) << 8) \
1330 | (((_instr_) & 0x00008000000LL) >> 20) \
1331 | (((_instr_) & 0x00000001fc0LL) >> 6))
1333 /* Allocate and initialize a frame cache. */
1337 {
1343 /* Base address. */
1359 }
1361 static CORE_ADDR
1363 frame_info_ptr this_frame,
1365 {
1366 CORE_ADDR next_pc;
1368 ia64_instruction_type it;
1384 CORE_ADDR addr;
1399 /* We want to check if we have a recognizable function start before we
1400 look ahead for a prologue. */
1403 {
1404 /* alloc - start of a regular function. */
1409 /* Verify that the current cfm matches what we think is the
1410 function start. If we have somehow jumped within a function,
1411 we do not want to interpret the prologue and calculate the
1412 addresses of various registers such as the return address.
1413 We will instead treat the frame as frameless. */
1422 }
1423 else
1424 {
1425 /* Look for a leaf routine. */
1429 {
1430 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
1438 {
1439 /* mov r2, r12 - beginning of leaf routine. */
1442 }
1443 }
1445 /* If we don't recognize a regular function or leaf routine, we are
1446 done. */
1448 {
1452 }
1453 }
1455 /* Loop, looking for prologue instructions, keeping track of
1456 where preserved registers were spilled. */
1458 {
1464 {
1465 /* Exit loop upon hitting a non-nop branch instruction. */
1469 }
1472 {
1473 /* Exit loop upon hitting a predicated instruction if
1474 we already have the return register or if we are frameless. */
1478 }
1480 {
1481 /* Move from BR */
1487 {
1490 }
1491 }
1494 {
1495 /* adds rN = imm14, rM (or mov rN, rM when imm14 is 0) */
1504 {
1505 /* mov rN, r12 */
1508 }
1510 {
1511 /* adds r12, -mem_stack_frame_size, r12 */
1514 }
1517 {
1519 /* adds r2, spilloffset, rFramePointer
1520 or
1521 adds r2, spilloffset, r12
1523 Get ready for stf.spill or st8.spill instructions.
1524 The address to start spilling at is loaded into r2.
1525 FIXME: Why r2? That's what gcc currently uses; it
1526 could well be different for other compilers. */
1528 /* Hmm... whether or not this will work will depend on
1529 where the pc is. If it's still early in the prologue
1530 this'll be wrong. FIXME */
1533 sp_regnum);
1534 spill_addr = saved_sp
1539 }
1542 {
1543 /* mov rN, rM where rM is an input register. */
1546 }
1549 {
1550 /* mov r12, r2 */
1553 }
1554 }
1558 {
1559 /* stf.spill [rN] = fM, imm9
1560 or
1561 stf.spill [rN] = fM */
1569 {
1574 else
1577 }
1578 }
1581 {
1582 /* mov.m rN = arM
1583 or
1584 mov.i rN = arM */
1590 {
1591 /* We have something like "mov.m r3 = ar.unat". Remember the
1592 r3 (or whatever) and watch for a store of this register... */
1595 }
1596 }
1598 {
1599 /* mov rN = pr */
1603 {
1606 }
1607 }
1611 {
1612 /* st8 [rN] = rM
1613 or
1614 st8 [rN] = rM, imm9 */
1621 {
1622 /* We've found a spill of either the UNAT register or the PR
1623 register. (Well, not exactly; what we've actually found is
1624 a spill of the register that UNAT or PR was moved to).
1625 Record that fact and move on... */
1627 {
1628 /* Track UNAT register. */
1631 }
1632 else
1633 {
1634 /* Track PR register. */
1637 }
1639 /* st8 [rN] = rM, imm9 */
1641 else
1644 }
1646 {
1647 /* Allow up to one store of each input register. */
1650 }
1653 {
1654 /* Allow an indirect store of an input register. */
1657 }
1658 }
1660 {
1661 /* One of
1662 st1 [rN] = rM
1663 st2 [rN] = rM
1664 st4 [rN] = rM
1665 st8 [rN] = rM
1666 Note that the st8 case is handled in the clause above.
1668 Advance over stores of input registers. One store per input
1669 register is permitted. */
1674 {
1677 }
1680 {
1681 /* Allow an indirect store of an input register. */
1684 }
1685 }
1687 {
1688 /* Either
1689 stfs [rN] = fM
1690 or
1691 stfd [rN] = fM
1693 Advance over stores of floating point input registers. Again
1694 one store per register is permitted. */
1698 {
1701 }
1702 }
1706 {
1707 /* st8.spill [rN] = rM
1708 or
1709 st8.spill [rN] = rM, imm9 */
1714 {
1715 /* We've found a spill of one of the preserved general purpose
1716 regs. Record the spill address and advance the spill
1717 register if appropriate. */
1720 /* st8.spill [rN] = rM, imm9 */
1722 else
1725 }
1726 }
1729 }
1731 /* If not frameless and we aren't called by skip_prologue, then we need
1732 to calculate registers for the previous frame which will be needed
1733 later. */
1736 {
1740 /* Extract the size of the rotating portion of the stack
1741 frame and the register rename base from the current
1742 frame marker. */
1749 /* Find the bof (beginning of frame). */
1755 {
1757 {
1759 }
1766 }
1768 /* For the previous argument registers we require the previous bof.
1769 If we can't find the previous cfm, then we can do nothing. */
1772 {
1775 }
1777 {
1780 }
1784 {
1790 /* The previous bof only requires subtraction of the sol (size of
1791 locals) due to the overlap between output and input of
1792 subsequent frames. */
1798 {
1800 {
1802 }
1807 else
1809 }
1811 }
1812 }
1814 /* Try and trust the lim_pc value whenever possible. */
1824 }
1826 CORE_ADDR
1828 {
1835 /* Call examine_prologue with - as third argument since we don't
1836 have a next frame pointer to send. */
1838 }
1841 /* Normal frames. */
1845 {
1850 CORE_ADDR cfm;
1861 /* We always want the bsp to point to the end of frame.
1862 This way, we can always get the beginning of frame (bof)
1863 by subtracting frame size. */
1886 }
1888 static void
1891 {
1896 /* If outermost frame, mark with null frame id. */
1901 "regular frame id: code %s, stack %s, "
1907 }
1912 {
1927 {
1931 /* We want to calculate the previous bsp as the end of the previous
1932 register stack frame. This corresponds to what the hardware bsp
1933 register will be if we pop the frame back which is why we might
1934 have been called. We know the beginning of the current frame is
1935 cache->bsp - cache->sof. This value in the previous frame points
1936 to the start of the output registers. We can calculate the end of
1937 that frame by adding the size of output:
1938 (sof (size of frame) - sol (size of locals)). */
1943 prev_bsp =
1947 }
1950 {
1961 IA64_PFS_REGNUM);
1963 }
1966 {
1967 /* If the function in question uses an automatic register (r32-r127)
1968 for the frame pointer, it'll be found by ia64_find_saved_register()
1969 above. If the function lacks one of these frame pointers, we can
1970 still provide a value since we know the size of the frame. */
1972 }
1975 {
1977 ULONGEST prN;
1980 IA64_PR_REGNUM);
1982 {
1983 /* Fetch predicate register rename base from current frame
1984 marker for this frame. */
1987 /* Adjust the register number to account for register rotation. */
1989 }
1993 }
1996 {
1998 ULONGEST unatN;
2000 IA64_UNAT_REGNUM);
2004 }
2007 {
2009 /* Find address of general register corresponding to nat bit we're
2010 interested in. */
2011 CORE_ADDR gr_addr;
2016 {
2017 /* Compute address of nat collection bits. */
2019 CORE_ADDR bsp;
2020 CORE_ADDR nat_collection;
2023 /* If our nat collection address is bigger than bsp, we have to get
2024 the nat collection from rnat. Otherwise, we fetch the nat
2025 collection from the computed address. */
2029 {
2032 }
2033 else
2037 }
2040 }
2043 {
2048 {
2051 }
2053 {
2056 }
2059 }
2062 {
2063 /* We don't know how to get the complete previous PSR, but we need it
2064 for the slot information when we unwind the pc (pc is formed of IP
2065 register plus slot information from PSR). To get the previous
2066 slot information, we mask it off the return address. */
2076 {
2079 }
2081 {
2084 }
2089 }
2092 {
2099 }
2103 {
2113 {
2117 /* FIXME: brobecker/2008-05-01: Doesn't this seem redundant
2118 with the same code above? */
2122 IA64_CFM_REGNUM);
2123 prev_cfm = extract_unsigned_integer
2126 IA64_BSP_REGNUM);
2127 prev_bsp = extract_unsigned_integer
2133 }
2136 }
2139 {
2143 {
2144 /* Fetch floating point register rename base from current
2145 frame marker for this frame. */
2148 /* Adjust the floating point register number to account for
2149 register rotation. */
2150 regnum = IA64_FR32_REGNUM
2152 }
2154 /* If we have stored a memory address, access the register. */
2158 /* Otherwise, punt and get the current value of the register. */
2159 else
2161 }
2162 }
2165 {
2167 NORMAL_FRAME,
2168 default_frame_unwind_stop_reason,
2171 NULL,
2172 default_frame_sniffer
2173 };
2175 /* Signal trampolines. */
2177 static void
2180 {
2185 {
2190 IA64_IP_REGNUM);
2193 IA64_CFM_REGNUM);
2196 IA64_PSR_REGNUM);
2199 IA64_BSP_REGNUM);
2202 IA64_RNAT_REGNUM);
2205 IA64_CCV_REGNUM);
2208 IA64_UNAT_REGNUM);
2211 IA64_FPSR_REGNUM);
2214 IA64_PFS_REGNUM);
2217 IA64_LC_REGNUM);
2228 }
2229 }
2233 {
2245 /* Note that frame size is hard-coded below. We cannot calculate it
2246 via prologue examination. */
2260 }
2262 static void
2265 {
2275 "sigtramp frame id: code %s, stack %s, "
2281 }
2286 {
2296 {
2301 {
2305 }
2308 }
2312 {
2322 }
2325 {
2332 }
2333 }
2335 static int
2337 frame_info_ptr this_frame,
2339 {
2343 {
2348 }
2351 }
2354 {
2356 SIGTRAMP_FRAME,
2357 default_frame_unwind_stop_reason,
2358 ia64_sigtramp_frame_this_id,
2359 ia64_sigtramp_frame_prev_register,
2360 NULL,
2361 ia64_sigtramp_frame_sniffer
2362 };
2364 \f
2366 static CORE_ADDR
2368 {
2372 }
2375 {
2377 ia64_frame_base_address,
2378 ia64_frame_base_address,
2379 ia64_frame_base_address
2380 };
2382 #ifdef HAVE_LIBUNWIND_IA64_H
2384 struct ia64_unwind_table_entry
2385 {
2386 unw_word_t start_offset;
2387 unw_word_t end_offset;
2388 unw_word_t info_offset;
2389 };
2393 {
2395 }
2397 /* Skip over a designated number of registers in the backing
2398 store, remembering every 64th position is for NAT. */
2401 {
2407 }
2409 /* Gdb ia64-libunwind-tdep callback function to convert from an ia64 gdb
2410 register number to a libunwind register number. */
2411 static int
2413 {
2438 else
2440 }
2442 /* Gdb ia64-libunwind-tdep callback function to convert from a libunwind
2443 register number to a ia64 gdb register number. */
2444 static int
2446 {
2469 else
2471 }
2473 /* Gdb ia64-libunwind-tdep callback function to reveal if register is
2474 a float register or not. */
2475 static int
2477 {
2479 }
2481 /* Libunwind callback accessor function for general registers. */
2482 static int
2485 {
2492 /* We never call any libunwind routines that need to write registers. */
2496 {
2498 /* Libunwind expects to see the pc value which means the slot number
2499 from the psr must be merged with the ip word address. */
2506 /* Libunwind expects to see the beginning of the current
2507 register frame so we must account for the fact that
2508 ptrace() will return a value for bsp that points *after*
2509 the current register frame. */
2517 /* Libunwind wants bspstore to be after the current register frame.
2518 This is what ptrace() and gdb treats as the regular bsp value. */
2523 /* For all other registers, just unwind the value directly. */
2526 }
2535 }
2537 /* Libunwind callback accessor function for floating-point registers. */
2538 static int
2541 {
2545 /* We never call any libunwind routines that need to write registers. */
2551 }
2553 /* Libunwind callback accessor function for top-level rse registers. */
2554 static int
2557 {
2563 /* We never call any libunwind routines that need to write registers. */
2567 {
2569 /* Libunwind expects to see the pc value which means the slot number
2570 from the psr must be merged with the ip word address. */
2577 /* Libunwind expects to see the beginning of the current
2578 register frame so we must account for the fact that
2579 ptrace() will return a value for bsp that points *after*
2580 the current register frame. */
2588 /* Libunwind wants bspstore to be after the current register frame.
2589 This is what ptrace() and gdb treats as the regular bsp value. */
2594 /* For all other registers, just unwind the value directly. */
2597 }
2607 }
2609 /* Libunwind callback accessor function for top-level fp registers. */
2610 static int
2613 {
2617 /* We never call any libunwind routines that need to write registers. */
2623 }
2625 /* Libunwind callback accessor function for accessing memory. */
2626 static int
2630 {
2632 {
2638 else
2641 }
2643 /* XXX do we need to normalize byte-order here? */
2646 else
2648 }
2650 /* Call low-level function to access the kernel unwind table. */
2653 {
2654 /* FIXME drow/2005-09-10: This code used to call
2655 ia64_linux_xfer_unwind_table directly to fetch the unwind table
2656 for the currently running ia64-linux kernel. That data should
2657 come from the core file and be accessed via the auxv vector; if
2658 we want to preserve fall back to the running kernel's table, then
2659 we should find a way to override the corefile layer's
2660 xfer_partial method. */
2664 }
2666 /* Get the kernel unwind table. */
2667 static int
2669 {
2673 {
2683 }
2705 }
2707 /* Find the unwind table entry for a specified address. */
2708 static int
2711 {
2715 CORE_ADDR load_base;
2727 {
2729 {
2742 }
2743 }
2748 /* Verify that the segment that contains the IP also contains
2749 the static unwind table. If not, we may be in the Linux kernel's
2750 DSO gate page in which case the unwind table is another segment.
2751 Otherwise, we are dealing with runtime-generated code, for which we
2752 have no info here. */
2756 {
2759 {
2762 {
2764 /* Get the segbase from the section containing the
2765 libunwind table. */
2767 }
2768 }
2771 }
2783 }
2785 /* Libunwind callback accessor function to acquire procedure unwind-info. */
2786 static int
2789 {
2791 unw_dyn_info_t di;
2796 {
2797 /* XXX This only works if the host and the target architecture are
2798 both ia64 and if the have (more or less) the same kernel
2799 version. */
2805 "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
2813 }
2814 else
2815 {
2822 "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
2830 }
2833 arg);
2835 /* We no longer need the dyn info storage so free it. */
2839 }
2841 /* Libunwind callback accessor function for cleanup. */
2842 static void
2845 {
2846 /* Nothing required for now. */
2847 }
2849 /* Libunwind callback accessor function to get head of the dynamic
2850 unwind-info registration list. */
2851 static int
2854 {
2857 unw_dyn_info_t di;
2864 {
2871 {
2873 /* We no longer need the dyn info storage so free it. */
2877 {
2880 "dynamic unwind table in objfile %s "
2886 }
2887 }
2888 }
2890 }
2893 /* Frame interface functions for libunwind. */
2895 static void
2898 {
2903 CORE_ADDR bsp;
2907 {
2910 }
2912 /* We must add the bsp as the special address for frame comparison
2913 purposes. */
2921 "libunwind frame id: code %s, stack %s, "
2927 }
2932 {
2943 /* Let libunwind do most of the work. */
2947 {
2948 ULONGEST prN_val;
2951 {
2953 ULONGEST cfm;
2955 /* Fetch predicate register rename base from current frame
2956 marker for this frame. */
2960 /* Adjust the register number to account for register rotation. */
2962 }
2966 }
2969 {
2970 ULONGEST unatN_val;
2975 }
2978 {
2982 /* We want to calculate the previous bsp as the end of the previous
2983 register stack frame. This corresponds to what the hardware bsp
2984 register will be if we pop the frame back which is why we might
2985 have been called. We know that libunwind will pass us back the
2986 beginning of the current frame so we should just add sof to it. */
2990 IA64_CFM_REGNUM);
2996 }
2997 else
2999 }
3001 static int
3003 frame_info_ptr this_frame,
3005 {
3011 }
3014 {
3016 NORMAL_FRAME,
3017 default_frame_unwind_stop_reason,
3018 ia64_libunwind_frame_this_id,
3019 ia64_libunwind_frame_prev_register,
3020 NULL,
3021 ia64_libunwind_frame_sniffer,
3022 libunwind_frame_dealloc_cache
3023 };
3025 static void
3029 {
3033 CORE_ADDR bsp;
3038 {
3041 }
3043 /* We must add the bsp as the special address for frame comparison
3044 purposes. */
3048 /* For a sigtramp frame, we don't make the check for previous ip being 0. */
3053 "libunwind sigtramp frame id: code %s, "
3059 }
3064 {
3068 CORE_ADDR prev_ip;
3070 /* If the previous frame pc value is 0, then we want to use the SIGCONTEXT
3071 method of getting previous registers. */
3073 IA64_IP_REGNUM);
3078 {
3081 regnum);
3082 }
3083 else
3085 }
3087 static int
3089 frame_info_ptr this_frame,
3091 {
3093 {
3097 }
3098 else
3100 }
3103 {
3105 SIGTRAMP_FRAME,
3106 default_frame_unwind_stop_reason,
3107 ia64_libunwind_sigtramp_frame_this_id,
3108 ia64_libunwind_sigtramp_frame_prev_register,
3109 NULL,
3110 ia64_libunwind_sigtramp_frame_sniffer
3111 };
3113 /* Set of libunwind callback acccessor functions. */
3114 unw_accessors_t ia64_unw_accessors =
3115 {
3116 ia64_find_proc_info_x,
3117 ia64_put_unwind_info,
3118 ia64_get_dyn_info_list,
3119 ia64_access_mem,
3120 ia64_access_reg,
3121 ia64_access_fpreg,
3122 /* resume */
3123 /* get_proc_name */
3124 };
3126 /* Set of special libunwind callback acccessor functions specific for accessing
3127 the rse registers. At the top of the stack, we want libunwind to figure out
3128 how to read r32 - r127. Though usually they are found sequentially in
3129 memory starting from $bof, this is not always true. */
3130 unw_accessors_t ia64_unw_rse_accessors =
3131 {
3132 ia64_find_proc_info_x,
3133 ia64_put_unwind_info,
3134 ia64_get_dyn_info_list,
3135 ia64_access_mem,
3136 ia64_access_rse_reg,
3137 ia64_access_rse_fpreg,
3138 /* resume */
3139 /* get_proc_name */
3140 };
3142 /* Set of ia64-libunwind-tdep gdb callbacks and data for generic
3143 ia64-libunwind-tdep code to use. */
3145 {
3146 ia64_gdb2uw_regnum,
3147 ia64_uw2gdb_regnum,
3148 ia64_is_fpreg,
3151 };
3155 static int
3157 {
3160 /* Don't use the struct convention for anything but structure,
3161 union, or array types. */
3167 /* HFAs are structures (or arrays) consisting entirely of floating
3168 point values of the same length. Up to 8 of these are returned
3169 in registers. Don't use the struct convention when this is the
3170 case. */
3176 /* Other structs of length 32 or less are returned in r8-r11.
3177 Don't use the struct convention for those either. */
3179 }
3181 /* Return non-zero if TYPE is a structure or union type. */
3183 static int
3185 {
3188 }
3190 static void
3193 {
3199 {
3206 {
3211 regnum++;
3212 }
3213 }
3215 {
3216 /* This is an integral value, and its size is less than 8 bytes.
3217 These values are LSB-aligned, so extract the relevant bytes,
3218 and copy them into VALBUF. */
3219 /* brobecker/2005-12-30: Actually, all integral values are LSB aligned,
3220 so I suppose we should also add handling here for integral values
3221 whose size is greater than 8. But I wasn't able to create such
3222 a type, neither in C nor in Ada, so not worrying about these yet. */
3224 ULONGEST val;
3228 }
3229 else
3230 {
3231 ULONGEST val;
3239 {
3240 ULONGEST regval;
3244 regnum++;
3245 }
3248 {
3251 }
3252 }
3253 }
3255 static void
3258 {
3264 {
3271 {
3276 regnum++;
3277 }
3278 }
3279 else
3280 {
3288 {
3289 ULONGEST val;
3293 regnum++;
3294 }
3297 {
3298 ULONGEST val;
3301 }
3302 }
3303 }
3305 static enum return_value_convention
3309 {
3313 {
3316 }
3319 {
3322 }
3326 else
3328 }
3330 static int
3332 {
3334 {
3338 else
3339 {
3342 }
3345 return
3347 etp);
3350 {
3358 }
3362 }
3365 }
3367 /* Determine if the given type is one of the floating point types or
3368 and HFA (which is a struct, array, or combination thereof whose
3369 bottom-most elements are all of the same floating point type). */
3373 {
3377 }
3380 /* Return 1 if the alignment of T is such that the next even slot
3381 should be used. Return 0, if the next available slot should
3382 be used. (See section 8.5.1 of the IA-64 Software Conventions
3383 and Runtime manual). */
3385 static int
3387 {
3389 {
3394 else
3397 return
3400 {
3408 }
3411 }
3412 }
3414 /* Attempt to find (and return) the global pointer for the given
3415 function.
3417 This is a rather nasty bit of code searchs for the .dynamic section
3418 in the objfile corresponding to the pc of the function we're trying
3419 to call. Once it finds the addresses at which the .dynamic section
3420 lives in the child process, it scans the Elf64_Dyn entries for a
3421 DT_PLTGOT tag. If it finds one of these, the corresponding
3422 d_un.d_ptr value is the global pointer. */
3424 static CORE_ADDR
3426 CORE_ADDR faddr)
3427 {
3433 {
3435 {
3437 {
3442 {
3444 LONGEST tag;
3453 {
3454 CORE_ADDR global_pointer;
3460 global_pointer
3462 byte_order);
3464 /* The payoff... */
3466 }
3472 }
3475 }
3476 }
3477 }
3479 }
3481 /* Attempt to find (and return) the global pointer for the given
3482 function. We first try the find_global_pointer_from_solib routine
3483 from the gdbarch tdep vector, if provided. And if that does not
3484 work, then we try ia64_find_global_pointer_from_dynamic_section. */
3486 static CORE_ADDR
3488 {
3497 }
3499 /* Given a function's address, attempt to find (and return) the
3500 corresponding (canonical) function descriptor. Return 0 if
3501 not found. */
3502 static CORE_ADDR
3504 {
3508 /* Return early if faddr is already a function descriptor. */
3514 {
3516 {
3518 {
3523 {
3525 LONGEST faddr2;
3537 }
3540 }
3541 }
3542 }
3544 }
3546 /* Attempt to find a function descriptor corresponding to the
3547 given address. If none is found, construct one on the
3548 stack using the address at fdaptr. */
3550 static CORE_ADDR
3552 {
3555 CORE_ADDR fdesc;
3560 {
3561 ULONGEST global_pointer;
3577 }
3580 }
3582 /* Use the following routine when printing out function pointers
3583 so the user can see the function address rather than just the
3584 function descriptor. */
3585 static CORE_ADDR
3588 {
3595 /* check if ADDR points to a function descriptor. */
3599 /* Normally, functions live inside a section that is executable.
3600 So, if ADDR points to a non-executable section, then treat it
3601 as a function descriptor and return the target address iff
3602 the target address itself points to a section that is executable.
3603 Check first the memory of the whole length of 8 bytes is readable. */
3606 {
3612 }
3614 /* There are also descriptors embedded in vtables. */
3616 {
3624 }
3627 }
3629 static CORE_ADDR
3631 {
3633 }
3635 /* The default "allocate_new_rse_frame" ia64_infcall_ops routine for ia64. */
3637 static void
3639 {
3655 }
3657 /* The default "store_argument_in_slot" ia64_infcall_ops routine for
3658 ia64. */
3660 static void
3663 {
3665 }
3667 /* The default "set_function_addr" ia64_infcall_ops routine for ia64. */
3669 static void
3671 {
3672 /* Nothing needed. */
3673 }
3675 static CORE_ADDR
3679 function_call_return_method return_method,
3680 CORE_ADDR struct_addr)
3681 {
3690 ULONGEST bsp;
3696 /* Count the number of slots needed for the arguments. */
3698 {
3704 nslots++;
3707 nfuncargs++;
3710 }
3712 /* Divvy up the slots between the RSE and the memory stack. */
3716 /* Allocate a new RSE frame. */
3720 /* We will attempt to find function descriptors in the .opd segment,
3721 but if we can't we'll construct them ourselves. That being the
3722 case, we'll need to reserve space on the stack for them. */
3726 /* Adjust the stack pointer to it's new value. The calling conventions
3727 require us to have 16 bytes of scratch, plus whatever space is
3728 necessary for the memory slots and our function descriptors. */
3732 /* Place the arguments where they belong. The arguments will be
3733 either placed in the RSE backing store or on the memory stack.
3734 In addition, floating point arguments or HFAs are placed in
3735 floating point registers. */
3739 {
3746 /* Special handling for function parameters. */
3750 {
3752 ULONGEST faddr = extract_unsigned_integer
3760 else
3762 slotnum++;
3764 }
3766 /* Normal slots. */
3768 /* Skip odd slot if necessary... */
3770 slotnum++;
3774 {
3779 {
3780 /* Integral types are LSB-aligned, so we have to be careful
3781 to insert the argument on the correct side of the buffer.
3782 This is why we use store_unsigned_integer. */
3783 store_unsigned_integer
3786 byte_order));
3787 }
3788 else
3789 {
3790 /* This is either an 8bit integral type, or an aggregate.
3791 For 8bit integral type, there is no problem, we just
3792 copy the value over.
3794 For aggregates, the only potentially tricky portion
3795 is to write the last one if it is less than 8 bytes.
3796 In this case, the data is Byte0-aligned. Happy news,
3797 this means that we don't need to differentiate the
3798 handling of 8byte blocks and less-than-8bytes blocks. */
3801 }
3806 else
3811 slotnum++;
3812 }
3814 /* Handle floating point types (including HFAs). */
3817 {
3821 {
3827 floatreg++;
3830 }
3831 }
3832 }
3834 /* Store the struct return value in r8 if necessary. */
3844 /* The following is not necessary on HP-UX, because we're using
3845 a dummy code sequence pushed on the stack to make the call, and
3846 this sequence doesn't need b0 to be set in order for our dummy
3847 breakpoint to be hit. Nonetheless, this doesn't interfere, and
3848 it's needed for other OSes, so we do this unconditionaly. */
3856 }
3859 {
3860 ia64_allocate_new_rse_frame,
3861 ia64_store_argument_in_slot,
3862 ia64_set_function_addr
3863 };
3865 static struct frame_id
3867 {
3885 }
3887 static CORE_ADDR
3889 {
3901 }
3903 static int
3905 {
3908 }
3910 /* The default "size_of_register_frame" gdbarch_tdep routine for ia64. */
3912 static int
3914 {
3916 }
3920 {
3921 /* If there is already a candidate, use it. */
3926 gdbarch *gdbarch
3932 /* According to the ia64 specs, instructions that store long double
3933 floats in memory use a long-double format different than that
3934 used in the floating registers. The memory format matches the
3935 x86 extended float format which is 80 bits. An OS may choose to
3936 use this format (e.g. GNU/Linux) or choose to use a different
3937 format for storing long doubles (e.g. HPUX). In the latter case,
3938 the setting of the format may be moved/overridden in an
3939 OS-specific tdep file. */
3973 ia64_memory_insert_breakpoint);
3975 ia64_memory_remove_breakpoint);
3981 /* Settings for calling functions in the inferior. */
3988 #ifdef HAVE_LIBUNWIND_IA64_H
3994 #else
3996 #endif
4000 /* Settings that should be unnecessary. */
4005 ia64_convert_from_func_ptr_addr);
4007 /* The virtual table contains 16-byte descriptors, not pointers to
4008 descriptors. */
4011 /* Hook in ABI-specific overrides, if they have been registered. */
4015 }
4018 void
4020 {
4022 }