| //===-- Win64EH.cpp - Win64 EH V3 Support -----------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements decoding helpers for V3 unwind information on Win64. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/Support/Win64EH.h" |
| #include "llvm/Support/Endian.h" |
| #include "llvm/Support/Error.h" |
| #include "llvm/Support/MathExtras.h" |
| |
| using namespace llvm; |
| using namespace llvm::Win64EH; |
| |
| StringRef Win64EH::getRegisterNameV3(unsigned Reg) { |
| static const char *const Names[] = { |
| "RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI", |
| "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15", |
| "R16", "R17", "R18", "R19", "R20", "R21", "R22", "R23", |
| "R24", "R25", "R26", "R27", "R28", "R29", "R30", "R31", |
| }; |
| if (Reg >= std::size(Names)) |
| return "<invalid>"; |
| return Names[Reg]; |
| } |
| |
| Expected<DecodedWOD> Win64EH::decodeWOD(ArrayRef<uint8_t> Pool, |
| unsigned Offset) { |
| if (Offset >= Pool.size()) |
| return createStringError("WOD pool overflow at offset %u", Offset); |
| |
| uint8_t FirstByte = Pool[Offset]; |
| DecodedWOD W = {}; |
| |
| // Determine opcode from variable-width prefix encoding. |
| // The dispatch order matters: check shorter prefixes first since they |
| // occupy the lowest bits, then fall through to longer prefixes. |
| // 3-bit prefix (bits [2:0] >= 4): opcodes 4-7 |
| // 4-bit prefix (bits [3:0] >= 8): opcodes 8-10 |
| // 6-bit prefix (bits [5:0] == 0x20): opcode 32 (PUSH2) |
| // 8-bit prefix (full byte 0-3): opcodes 0-3 |
| uint8_t Low3 = FirstByte & 0x07; |
| |
| // 3-bit opcode: bits [2:0] in {4, 5, 6, 7} |
| if (Low3 >= 4) { |
| switch (Low3) { |
| case WOD_PUSH: { |
| W.Opcode = WOD_PUSH; |
| W.ByteSize = 1; |
| W.Register = (FirstByte >> 3) & 0x1F; // 5-bit register |
| return W; |
| } |
| case WOD_SAVE_NONVOL_FAR: { |
| W.Opcode = WOD_SAVE_NONVOL_FAR; |
| W.ByteSize = 5; |
| if (Offset + 5 > Pool.size()) |
| return createStringError("WOD_SAVE_NONVOL_FAR truncated at offset %u", |
| Offset); |
| W.Register = (FirstByte >> 3) & 0x1F; |
| W.Displacement = support::endian::read32le(&Pool[Offset + 1]); |
| return W; |
| } |
| case WOD_SAVE_NONVOL: { |
| W.Opcode = WOD_SAVE_NONVOL; |
| W.ByteSize = 3; |
| if (Offset + 3 > Pool.size()) |
| return createStringError("WOD_SAVE_NONVOL truncated at offset %u", |
| Offset); |
| W.Register = (FirstByte >> 3) & 0x1F; |
| W.Displacement = |
| (uint32_t)support::endian::read16le(&Pool[Offset + 1]) * 8; |
| return W; |
| } |
| case WOD_PUSH_CONSECUTIVE_2: { |
| W.Opcode = WOD_PUSH_CONSECUTIVE_2; |
| W.ByteSize = 1; |
| W.Register = (FirstByte >> 3) & 0x1F; |
| if (W.Register > 30) |
| return createStringError( |
| "WOD_PUSH_CONSECUTIVE_2 Register=%u out of range [0,30] at pool " |
| "offset %u", |
| W.Register, Offset); |
| return W; |
| } |
| default: |
| return createStringError("unknown WOD opcode 0x%02X at pool offset %u", |
| FirstByte, Offset); |
| } |
| } |
| |
| // 4-bit opcode: bits [3:0] in {8, 9, 10, ...} |
| uint8_t Low4 = FirstByte & 0x0F; |
| if (Low4 >= 8) { |
| switch (Low4) { |
| case WOD_ALLOC_SMALL: { |
| W.Opcode = WOD_ALLOC_SMALL; |
| W.ByteSize = 1; |
| W.Size = (unsigned)(((FirstByte >> 4) & 0x0F) + 1) * 8; |
| return W; |
| } |
| case WOD_SAVE_XMM128_FAR: { |
| W.Opcode = WOD_SAVE_XMM128_FAR; |
| W.ByteSize = 5; |
| if (Offset + 5 > Pool.size()) |
| return createStringError("WOD_SAVE_XMM128_FAR truncated at offset %u", |
| Offset); |
| W.Register = (FirstByte >> 4) & 0x0F; |
| W.Displacement = support::endian::read32le(&Pool[Offset + 1]); |
| return W; |
| } |
| case WOD_SAVE_XMM128: { |
| W.Opcode = WOD_SAVE_XMM128; |
| W.ByteSize = 3; |
| if (Offset + 3 > Pool.size()) |
| return createStringError("WOD_SAVE_XMM128 truncated at offset %u", |
| Offset); |
| W.Register = (FirstByte >> 4) & 0x0F; |
| W.Displacement = |
| (uint32_t)support::endian::read16le(&Pool[Offset + 1]) * 16; |
| return W; |
| } |
| default: |
| return createStringError("unknown WOD opcode 0x%02X at pool offset %u", |
| FirstByte, Offset); |
| } |
| } |
| |
| // 6-bit opcode: bits [5:0] == 0x20 (WOD_PUSH2) |
| uint8_t Low6 = FirstByte & 0x3F; |
| if (Low6 == WOD_PUSH2) { |
| W.Opcode = WOD_PUSH2; |
| W.ByteSize = 2; |
| if (Offset + 2 > Pool.size()) |
| return createStringError("WOD_PUSH2 truncated at offset %u", Offset); |
| uint8_t SecondByte = Pool[Offset + 1]; |
| // First reg from bits [7:6] of first byte (2 bits) and bits [2:0] of second |
| // (3 bits) |
| W.Register = ((FirstByte >> 6) & 0x03) | ((SecondByte & 0x07) << 2); |
| W.Register2 = (SecondByte >> 3) & 0x1F; |
| return W; |
| } |
| |
| // 8-bit opcode: full byte is opcode (values 0-3) |
| switch (FirstByte) { |
| case WOD_SET_FPREG: { |
| W.Opcode = WOD_SET_FPREG; |
| W.ByteSize = 2; |
| if (Offset + 2 > Pool.size()) |
| return createStringError("WOD_SET_FPREG truncated at offset %u", Offset); |
| uint8_t SecondByte = Pool[Offset + 1]; |
| W.Register = SecondByte & 0x0F; // 4-bit register |
| W.Displacement = (unsigned)((SecondByte >> 4) & 0x0F) * 16; |
| return W; |
| } |
| case WOD_ALLOC_HUGE: { |
| W.Opcode = WOD_ALLOC_HUGE; |
| W.ByteSize = 5; |
| if (Offset + 5 > Pool.size()) |
| return createStringError("WOD_ALLOC_HUGE truncated at offset %u", Offset); |
| W.Size = support::endian::read32le(&Pool[Offset + 1]); |
| return W; |
| } |
| case WOD_ALLOC_LARGE: { |
| W.Opcode = WOD_ALLOC_LARGE; |
| W.ByteSize = 3; |
| if (Offset + 3 > Pool.size()) |
| return createStringError("WOD_ALLOC_LARGE truncated at offset %u", |
| Offset); |
| W.Size = (uint32_t)support::endian::read16le(&Pool[Offset + 1]) * 8; |
| return W; |
| } |
| case WOD_PUSH_CANONICAL_FRAME: { |
| W.Opcode = WOD_PUSH_CANONICAL_FRAME; |
| W.ByteSize = 2; |
| if (Offset + 2 > Pool.size()) |
| return createStringError( |
| "WOD_PUSH_CANONICAL_FRAME truncated at offset %u", Offset); |
| W.Type = Pool[Offset + 1]; |
| return W; |
| } |
| default: |
| return createStringError("unknown WOD opcode 0x%02X at pool offset %u", |
| FirstByte, Offset); |
| } |
| } |
| |
| Expected<DecodedUnwindInfoV3> |
| Win64EH::decodeUnwindInfoV3(ArrayRef<uint8_t> Data) { |
| if (Data.size() < 4) |
| return createStringError("V3 unwind info too short: %zu bytes", |
| Data.size()); |
| |
| DecodedUnwindInfoV3 Info; |
| Info.Version = Data[0] & 0x07; |
| Info.Flags = (Data[0] >> 3) & 0x1F; |
| Info.SizeOfProlog = Data[1]; |
| Info.PayloadWords = Data[2]; |
| Info.NumberOfOps = Data[3] & 0x1F; |
| Info.NumberOfEpilogs = (Data[3] >> 5) & 0x07; |
| |
| // The fixed header is always 4 bytes. When UNW_FlagLarge is set, the first |
| // byte of the payload is the UNWIND_INFO_LARGE_V3 extension byte (which |
| // extends SizeOfProlog to 16 bits and widens prolog IP offset entries to |
| // 16 bits). That byte IS counted in PayloadWords. |
| unsigned Offset = 4; // Start of payload |
| |
| // Compute the end of the payload area declared by PayloadWords. All |
| // subsequent reads of payload structures (the optional UNWIND_INFO_LARGE_V3 |
| // byte, prolog IP offsets, epilog descriptors) must stay within this region; |
| // reading past it would either overflow the buffer or cross into the |
| // trailing handler/chain data, both of which indicate a malformed record. |
| unsigned PayloadEnd = 4 + Info.PayloadWords * 2; |
| if (PayloadEnd > Data.size()) |
| return createStringError( |
| "V3 unwind info PayloadWords (%u) extends past end of buffer", |
| Info.PayloadWords); |
| |
| bool IsLarge = Info.isLarge(); |
| if (IsLarge) { |
| if (Offset >= PayloadEnd) |
| return createStringError( |
| "V3 unwind info with UNW_FlagLarge too short: PayloadWords (%u) " |
| "leaves no room for UNWIND_INFO_LARGE_V3", |
| Info.PayloadWords); |
| Info.SizeOfProlog |= static_cast<uint16_t>(Data[Offset]) << 8; |
| Offset += 1; |
| } |
| |
| // Read prolog IP offsets (8-bit each, or 16-bit when LARGE) |
| for (unsigned I = 0; I < Info.NumberOfOps; ++I) { |
| if (IsLarge) { |
| if (Offset + 2 > PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading prolog IP offset %u", I); |
| Info.PrologIpOffsets.push_back(support::endian::read16le(&Data[Offset])); |
| Offset += 2; |
| } else { |
| if (Offset >= PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading prolog IP offset %u", I); |
| Info.PrologIpOffsets.push_back(Data[Offset++]); |
| } |
| } |
| |
| // Read epilog descriptors |
| int32_t PrevResolvedOffset = 0; |
| for (unsigned I = 0; I < Info.NumberOfEpilogs; ++I) { |
| DecodedEpilogV3 Epi; |
| if (Offset >= PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading epilog %u FlagsAndNumOps", I); |
| uint8_t FlagsAndNumOps = Data[Offset++]; |
| Epi.Flags = FlagsAndNumOps & 0x07; |
| Epi.NumberOfOps = (FlagsAndNumOps >> 3) & 0x1F; |
| |
| if (Offset + 2 > PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading epilog %u EpilogOffset", I); |
| int16_t RawOffset = |
| static_cast<int16_t>(support::endian::read16le(&Data[Offset])); |
| Offset += 2; |
| |
| // The first epilog's EpilogOffset is absolute (from fragment start or |
| // tail). Subsequent epilogs store a delta from the previous epilog's |
| // resolved position. Accumulate to resolve all to absolute. |
| if (I == 0) |
| Epi.EpilogOffset = RawOffset; |
| else |
| Epi.EpilogOffset = PrevResolvedOffset + RawOffset; |
| PrevResolvedOffset = Epi.EpilogOffset; |
| |
| // Inherited descriptors (NumberOfOps == 0) are only 3 bytes: |
| // FlagsAndNumOps(1) + EpilogOffset(2). They have no FirstOp, |
| // IpOffsetOfLastInstruction, or IP offset fields appended; instead, |
| // the previous epilog's Flags bits 0 and 1, FirstOp, |
| // IpOffsetOfLastInstruction, and IP offset array are inherited. |
| // |
| // If this is the first epilog there is no previous descriptor to |
| // inherit from — the record is malformed. We leave the extended fields |
| // zero-initialized so callers can still see the (broken) header and |
| // EpilogOffset; downstream consumers (e.g. the dumpers) surface a |
| // warning when they encounter NumberOfOps == 0 at index 0. |
| if (Epi.NumberOfOps == 0) { |
| if (!Info.Epilogs.empty()) { |
| const DecodedEpilogV3 &Prev = Info.Epilogs.back(); |
| // Flags bits 0 (EPILOG_INFO_PARENT_FRAGMENT_TRANSFER) and 1 |
| // (EPILOG_INFO_LARGE) are inherited from the previous epilog; any |
| // bits present in this descriptor's own flags byte at those |
| // positions are ignored. Bit 2 (reserved) keeps its raw read value. |
| Epi.Flags = (Epi.Flags & uint8_t{0xFC}) | (Prev.Flags & uint8_t{0x03}); |
| Epi.FirstOp = Prev.FirstOp; |
| Epi.IpOffsetOfLastInstruction = Prev.IpOffsetOfLastInstruction; |
| Epi.IpOffsets = Prev.IpOffsets; |
| } else { |
| Epi.FirstOp = 0; |
| Epi.IpOffsetOfLastInstruction = 0; |
| } |
| Info.Epilogs.push_back(std::move(Epi)); |
| continue; |
| } |
| |
| bool EpiLarge = Epi.isLarge(); |
| |
| if (Offset + 2 > PayloadEnd) |
| return createStringError("V3 payload truncated reading epilog %u FirstOp", |
| I); |
| Epi.FirstOp = support::endian::read16le(&Data[Offset]); |
| Offset += 2; |
| |
| // IpOffsetOfLastInstruction: 8-bit normally, 16-bit when EPILOG_INFO_LARGE |
| if (EpiLarge) { |
| if (Offset + 2 > PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading epilog %u IpOffsetOfLastInstruction", |
| I); |
| Epi.IpOffsetOfLastInstruction = support::endian::read16le(&Data[Offset]); |
| Offset += 2; |
| } else { |
| if (Offset >= PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading epilog %u IpOffsetOfLastInstruction", |
| I); |
| Epi.IpOffsetOfLastInstruction = Data[Offset++]; |
| } |
| |
| // Read epilog IP offsets (8-bit each, or 16-bit when EPILOG_INFO_LARGE) |
| for (unsigned J = 0; J < Epi.NumberOfOps; ++J) { |
| if (EpiLarge) { |
| if (Offset + 2 > PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading epilog %u IP offset %u", I, J); |
| Epi.IpOffsets.push_back(support::endian::read16le(&Data[Offset])); |
| Offset += 2; |
| } else { |
| if (Offset >= PayloadEnd) |
| return createStringError( |
| "V3 payload truncated reading epilog %u IP offset %u", I, J); |
| Epi.IpOffsets.push_back(Data[Offset++]); |
| } |
| } |
| |
| Info.Epilogs.push_back(std::move(Epi)); |
| } |
| |
| // Identify WOD pool: everything from current offset until the end of |
| // the payload area declared by PayloadWords. |
| if (Offset < PayloadEnd) |
| Info.WODPool = Data.slice(Offset, PayloadEnd - Offset); |
| else |
| Info.WODPool = ArrayRef<uint8_t>(); |
| |
| // When PayloadWords is odd, the encoder emits 2 trailing zero bytes inside |
| // the payload region as padding before the handler/chain. Report the |
| // aligned offset so consumers locate the next field correctly. |
| Info.PayloadSize = alignTo(PayloadEnd, 4); |
| |
| return Info; |
| } |
