Daniel Paoliello
878bbacfb0
The Windows x64 unwind v3 spec was clarified (MicrosoftDocs/cpp-docs#5936) to state that an EPILOG_INFO_V3 record with `NumberOfOps == 0` inherits its effective fields from the first *preceding* descriptor with `NumberOfOps != 0` (the "base"), not the immediately preceding one. Additionally, Flags bits 0 and 1 are no longer inherited; the producer must replicate them so they match the base descriptor. - Encoder (MCWin64EH.cpp): compare each epilog against the tracked base descriptor, and emit EPILOG_INFO_LARGE in inherited descriptors' own flags byte. - Decoder (Win64EH.cpp): track the base index and inherit from it; keep the record's own flags byte instead of copying the previous record's. - Dumpers (llvm-readobj, llvm-objdump): reword "previous epilog" to "base epilog". - Tests: update multi-epilog expectations and add a LARGE inherited-epilog case to seh-unwindv3-inheritance.s.
379 lines
14 KiB
C++
379 lines
14 KiB
C++
//===-- 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;
|
|
// Index of the most recent full descriptor (NumberOfOps != 0). Per the V3
|
|
// spec, a descriptor with NumberOfOps == 0 inherits its effective fields
|
|
// from the first *preceding* descriptor with NumberOfOps != 0, which is not
|
|
// necessarily the immediately preceding descriptor.
|
|
int BaseEpilogIdx = -1;
|
|
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
|
|
// effective NumberOfOps, FirstOp, IpOffsetOfLastInstruction, and IP offset
|
|
// array are inherited from the first preceding descriptor with
|
|
// NumberOfOps != 0 (the "base"). Per the V3 spec, Flags bits 0 and 1 are
|
|
// NOT inherited: the producer is required to replicate them into this
|
|
// record, so we keep the value read from this descriptor's own flags byte.
|
|
//
|
|
// If there is no preceding base 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 (BaseEpilogIdx >= 0) {
|
|
const DecodedEpilogV3 &Base = Info.Epilogs[BaseEpilogIdx];
|
|
// Flags bits 0 and 1 are producer-replicated, not inherited: a
|
|
// compliant producer must have written the base's values into this
|
|
// descriptor's own flags byte, so they should already match the base.
|
|
// We intentionally keep this record's own bits (rather than copying
|
|
// the base's) so a non-compliant producer is not silently masked. This
|
|
// decoder runs on potentially-malformed object files, so a mismatch is
|
|
// not asserted here; downstream consumers (the dumpers) surface a
|
|
// warning when the replicated bits disagree with the base.
|
|
Epi.FirstOp = Base.FirstOp;
|
|
Epi.IpOffsetOfLastInstruction = Base.IpOffsetOfLastInstruction;
|
|
Epi.IpOffsets = Base.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++]);
|
|
}
|
|
}
|
|
|
|
// This is a full descriptor (NumberOfOps != 0); it becomes the base that
|
|
// subsequent inherited descriptors reference.
|
|
BaseEpilogIdx = Info.Epilogs.size();
|
|
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;
|
|
}
|