//===-- llvm/Support/WinARMEH.h - Windows on ARM EH Constants ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_ARMWINEH_H
#define LLVM_SUPPORT_ARMWINEH_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Endian.h"
namespace llvm {
namespace ARM {
namespace WinEH {
enum class RuntimeFunctionFlag {
RFF_Unpacked, /// unpacked entry
RFF_Packed, /// packed entry
RFF_PackedFragment, /// packed entry representing a fragment
RFF_Reserved, /// reserved
};
enum class ReturnType {
RT_POP, /// return via pop {pc} (L flag must be set)
RT_B, /// 16-bit branch
RT_BW, /// 32-bit branch
RT_NoEpilogue, /// no epilogue (fragment)
};
/// RuntimeFunction - An entry in the table of procedure data (.pdata)
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +---------------------------------------------------------------+
/// | Function Start RVA |
/// +-------------------+-+-+-+-----+-+---+---------------------+---+
/// | Stack Adjust |C|L|R| Reg |H|Ret| Function Length |Flg|
/// +-------------------+-+-+-+-----+-+---+---------------------+---+
///
/// Flag : 2-bit field with the following meanings:
/// - 00 = packed unwind data not used; reamining bits point to .xdata record
/// - 01 = packed unwind data
/// - 10 = packed unwind data, function assumed to have no prologue; useful
/// for function fragments that are discontiguous with the start of the
/// function
/// - 11 = reserved
/// Function Length : 11-bit field providing the length of the entire function
/// in bytes, divided by 2; if the function is greater than
/// 4KB, a full .xdata record must be used instead
/// Ret : 2-bit field indicating how the function returns
/// - 00 = return via pop {pc} (the L bit must be set)
/// - 01 = return via 16-bit branch
/// - 10 = return via 32-bit branch
/// - 11 = no epilogue; useful for function fragments that may only contain a
/// prologue but the epilogue is elsewhere
/// H : 1-bit flag indicating whether the function "homes" the integer parameter
/// registers (r0-r3), allocating 16-bytes on the stack
/// Reg : 3-bit field indicating the index of the last saved non-volatile
/// register. If the R bit is set to 0, then only integer registers are
/// saved (r4-rN, where N is 4 + Reg). If the R bit is set to 1, then
/// only floating-point registers are being saved (d8-dN, where N is
/// 8 + Reg). The special case of the R bit being set to 1 and Reg equal
/// to 7 indicates that no registers are saved.
/// R : 1-bit flag indicating whether the non-volatile registers are integer or
/// floating-point. 0 indicates integer, 1 indicates floating-point. The
/// special case of the R-flag being set and Reg being set to 7 indicates
/// that no non-volatile registers are saved.
/// L : 1-bit flag indicating whether the function saves/restores the link
/// register (LR)
/// C : 1-bit flag indicating whether the function includes extra instructions
/// to setup a frame chain for fast walking. If this flag is set, r11 is
/// implicitly added to the list of saved non-volatile integer registers.
/// Stack Adjust : 10-bit field indicating the number of bytes of stack that are
/// allocated for this function. Only values between 0x000 and
/// 0x3f3 can be directly encoded. If the value is 0x3f4 or
/// greater, then the low 4 bits have special meaning as follows:
/// - Bit 0-1
/// indicate the number of words' of adjustment (1-4), minus 1
/// - Bit 2
/// indicates if the prologue combined adjustment into push
/// - Bit 3
/// indicates if the epilogue combined adjustment into pop
///
/// RESTRICTIONS:
/// - IF C is SET:
/// + L flag must be set since frame chaining requires r11 and lr
/// + r11 must NOT be included in the set of registers described by Reg
/// - IF Ret is 0:
/// + L flag must be set
// NOTE: RuntimeFunction is meant to be a simple class that provides raw access
// to all fields in the structure. The accessor methods reflect the names of
// the bitfields that they correspond to. Although some obvious simplifications
// are possible via merging of methods, it would prevent the use of this class
// to fully inspect the contents of the data structure which is particularly
// useful for scenarios such as llvm-readobj to aid in testing.
class RuntimeFunction {
public:
const support::ulittle32_t BeginAddress;
const support::ulittle32_t UnwindData;
RuntimeFunction(const support::ulittle32_t *Data)
: BeginAddress(Data[0]), UnwindData(Data[1]) {}
RuntimeFunction(const support::ulittle32_t BeginAddress,
const support::ulittle32_t UnwindData)
: BeginAddress(BeginAddress), UnwindData(UnwindData) {}
RuntimeFunctionFlag Flag() const {
return RuntimeFunctionFlag(UnwindData & 0x3);
}
uint32_t ExceptionInformationRVA() const {
assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
"unpacked form required for this operation");
return (UnwindData & ~0x3);
}
uint32_t PackedUnwindData() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return (UnwindData & ~0x3);
}
uint32_t FunctionLength() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return (((UnwindData & 0x00001ffc) >> 2) << 1);
}
ReturnType Ret() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
assert(((UnwindData & 0x00006000) || L()) && "L must be set to 1");
return ReturnType((UnwindData & 0x00006000) >> 13);
}
bool H() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return ((UnwindData & 0x00008000) >> 15);
}
uint8_t Reg() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return ((UnwindData & 0x00070000) >> 16);
}
bool R() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return ((UnwindData & 0x00080000) >> 19);
}
bool L() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return ((UnwindData & 0x00100000) >> 20);
}
bool C() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
assert(((~UnwindData & 0x00200000) || L()) &&
"L flag must be set, chaining requires r11 and LR");
assert(((~UnwindData & 0x00200000) || (Reg() < 7) || R()) &&
"r11 must not be included in Reg; C implies r11");
return ((UnwindData & 0x00200000) >> 21);
}
uint16_t StackAdjust() const {
assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
"packed form required for this operation");
return ((UnwindData & 0xffc00000) >> 22);
}
};
/// PrologueFolding - pseudo-flag derived from Stack Adjust indicating that the
/// prologue has stack adjustment combined into the push
inline bool PrologueFolding(const RuntimeFunction &RF) {
return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x4);
}
/// Epilogue - pseudo-flag derived from Stack Adjust indicating that the
/// epilogue has stack adjustment combined into the pop
inline bool EpilogueFolding(const RuntimeFunction &RF) {
return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x8);
}
/// StackAdjustment - calculated stack adjustment in words. The stack
/// adjustment should be determined via this function to account for the special
/// handling the special encoding when the value is >= 0x3f4.
inline uint16_t StackAdjustment(const RuntimeFunction &RF) {
uint16_t Adjustment = RF.StackAdjust();
if (Adjustment >= 0x3f4)
return (Adjustment & 0x3) ? ((Adjustment & 0x3) << 2) - 1 : 0;
return Adjustment;
}
/// SavedRegisterMask - Utility function to calculate the set of saved general
/// purpose (r0-r15) and VFP (d0-d31) registers.
std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF);
/// ExceptionDataRecord - An entry in the table of exception data (.xdata)
///
/// The format on ARM is:
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +-------+---------+-+-+-+---+-----------------------------------+
/// | C Wrd | Epi Cnt |F|E|X|Ver| Function Length |
/// +-------+--------+'-'-'-'---'---+-------------------------------+
/// | Reserved |Ex. Code Words| (Extended Epilogue Count) |
/// +-------+--------+--------------+-------------------------------+
///
/// The format on ARM64 is:
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +---------+---------+-+-+---+-----------------------------------+
/// | C Wrd | Epi Cnt |E|X|Ver| Function Length |
/// +---------+------+--'-'-'---'---+-------------------------------+
/// | Reserved |Ex. Code Words| (Extended Epilogue Count) |
/// +-------+--------+--------------+-------------------------------+
///
/// Function Length : 18-bit field indicating the total length of the function
/// in bytes divided by 2. If a function is larger than
/// 512KB, then multiple pdata and xdata records must be used.
/// Vers : 2-bit field describing the version of the remaining structure. Only
/// version 0 is currently defined (values 1-3 are not permitted).
/// X : 1-bit field indicating the presence of exception data
/// E : 1-bit field indicating that the single epilogue is packed into the
/// header
/// F : 1-bit field indicating that the record describes a function fragment
/// (implies that no prologue is present, and prologue processing should be
/// skipped) (ARM only)
/// Epilogue Count : 5-bit field that differs in meaning based on the E field.
///
/// If E is set, then this field specifies the index of the
/// first unwind code describing the (only) epilogue.
///
/// Otherwise, this field indicates the number of exception
/// scopes. If more than 31 scopes exist, then this field and
/// the Code Words field must both be set to 0 to indicate that
/// an extension word is required.
/// Code Words : 4-bit (5-bit on ARM64) field that specifies the number of
/// 32-bit words needed to contain all the unwind codes. If more
/// than 15 words (31 words on ARM64) are required, then this field
/// and the Epilogue Count field must both be set to 0 to indicate
/// that an extension word is required.
/// Extended Epilogue Count, Extended Code Words :
/// Valid only if Epilog Count and Code Words are both
/// set to 0. Provides an 8-bit extended code word
/// count and 16-bits for epilogue count
///
/// The epilogue scope format on ARM is:
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +----------------+------+---+---+-------------------------------+
/// | Ep Start Idx | Cond |Res| Epilogue Start Offset |
/// +----------------+------+---+-----------------------------------+
///
/// The epilogue scope format on ARM64 is:
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +-------------------+-------+---+-------------------------------+
/// | Ep Start Idx | Res | Epilogue Start Offset |
/// +-------------------+-------+-----------------------------------+
///
/// If the E bit is unset in the header, the header is followed by a series of
/// epilogue scopes, which are sorted by their offset.
///
/// Epilogue Start Offset: 18-bit field encoding the offset of epilogue relative
/// to the start of the function in bytes divided by two
/// Res : 2-bit field reserved for future expansion (must be set to 0)
/// Condition : (ARM only) 4-bit field providing the condition under which the
/// epilogue is executed. Unconditional epilogues should set this
/// field to 0xe. Epilogues must be entirely conditional or
/// unconditional, and in Thumb-2 mode. The epilogue begins with
/// the first instruction after the IT opcode.
/// Epilogue Start Index : 8-bit field indicating the byte index of the first
/// unwind code describing the epilogue
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +---------------+---------------+---------------+---------------+
/// | Unwind Code 3 | Unwind Code 2 | Unwind Code 1 | Unwind Code 0 |
/// +---------------+---------------+---------------+---------------+
///
/// Following the epilogue scopes, the byte code describing the unwinding
/// follows. This is padded to align up to word alignment. Bytes are stored in
/// little endian.
///
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +---------------------------------------------------------------+
/// | Exception Handler RVA (requires X = 1) |
/// +---------------------------------------------------------------+
/// | (possibly followed by data required for exception handler) |
/// +---------------------------------------------------------------+
///
/// If the X bit is set in the header, the unwind byte code is followed by the
/// exception handler information. This constants of one Exception Handler RVA
/// which is the address to the exception handler, followed immediately by the
/// variable length data associated with the exception handler.
///
struct EpilogueScope {
const support::ulittle32_t ES;
EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
// Same for both ARM and AArch64.
uint32_t EpilogueStartOffset() const {
return (ES & 0x0003ffff);
}
// Different implementations for ARM and AArch64.
uint8_t ResARM() const {
return ((ES & 0x000c0000) >> 18);
}
uint8_t ResAArch64() const {
return ((ES & 0x000f0000) >> 18);
}
// Condition is only applicable to ARM.
uint8_t Condition() const {
return ((ES & 0x00f00000) >> 20);
}
// Different implementations for ARM and AArch64.
uint8_t EpilogueStartIndexARM() const {
return ((ES & 0xff000000) >> 24);
}
uint16_t EpilogueStartIndexAArch64() const {
return ((ES & 0xffc00000) >> 22);
}
};
struct ExceptionDataRecord;
inline size_t HeaderWords(const ExceptionDataRecord &XR);
struct ExceptionDataRecord {
const support::ulittle32_t *Data;
bool isAArch64;
ExceptionDataRecord(const support::ulittle32_t *Data, bool isAArch64) :
Data(Data), isAArch64(isAArch64) {}
uint32_t FunctionLength() const {
return (Data[0] & 0x0003ffff);
}
uint32_t FunctionLengthInBytesARM() const {
return FunctionLength() << 1;
}
uint32_t FunctionLengthInBytesAArch64() const {
return FunctionLength() << 2;
}
uint8_t Vers() const {
return (Data[0] & 0x000C0000) >> 18;
}
bool X() const {
return ((Data[0] & 0x00100000) >> 20);
}
bool E() const {
return ((Data[0] & 0x00200000) >> 21);
}
bool F() const {
assert(!isAArch64 && "Fragments are only supported on ARMv7 WinEH");
return ((Data[0] & 0x00400000) >> 22);
}
uint8_t EpilogueCount() const {
if (HeaderWords(*this) == 1) {
if (isAArch64)
return (Data[0] & 0x07C00000) >> 22;
return (Data[0] & 0x0f800000) >> 23;
}
return Data[1] & 0x0000ffff;
}
uint8_t CodeWords() const {
if (HeaderWords(*this) == 1) {
if (isAArch64)
return (Data[0] & 0xf8000000) >> 27;
return (Data[0] & 0xf0000000) >> 28;
}
return (Data[1] & 0x00ff0000) >> 16;
}
ArrayRef<support::ulittle32_t> EpilogueScopes() const {
assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
size_t Offset = HeaderWords(*this);
return makeArrayRef(&Data[Offset], EpilogueCount());
}
ArrayRef<uint8_t> UnwindByteCode() const {
const size_t Offset = HeaderWords(*this)
+ (E() ? 0 : EpilogueCount());
const uint8_t *ByteCode =
reinterpret_cast<const uint8_t *>(&Data[Offset]);
return makeArrayRef(ByteCode, CodeWords() * sizeof(uint32_t));
}
uint32_t ExceptionHandlerRVA() const {
assert(X() && "Exception Handler RVA is only valid if the X bit is set");
return Data[HeaderWords(*this) + EpilogueCount() + CodeWords()];
}
uint32_t ExceptionHandlerParameter() const {
assert(X() && "Exception Handler RVA is only valid if the X bit is set");
return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1];
}
};
inline size_t HeaderWords(const ExceptionDataRecord &XR) {
if (XR.isAArch64)
return (XR.Data[0] & 0xffc00000) ? 1 : 2;
return (XR.Data[0] & 0xff800000) ? 1 : 2;
}
}
}
}
#endif