Home | History | Annotate | Download | only in Support
      1 //===-- llvm/Support/WinARMEH.h - Windows on ARM EH Constants ---*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #ifndef LLVM_SUPPORT_WINARMEH_H
     11 #define LLVM_SUPPORT_WINARMEH_H
     12 
     13 #include "llvm/ADT/ArrayRef.h"
     14 #include "llvm/Support/Endian.h"
     15 
     16 namespace llvm {
     17 namespace ARM {
     18 namespace WinEH {
     19 enum class RuntimeFunctionFlag {
     20   RFF_Unpacked,       /// unpacked entry
     21   RFF_Packed,         /// packed entry
     22   RFF_PackedFragment, /// packed entry representing a fragment
     23   RFF_Reserved,       /// reserved
     24 };
     25 
     26 enum class ReturnType {
     27   RT_POP,             /// return via pop {pc} (L flag must be set)
     28   RT_B,               /// 16-bit branch
     29   RT_BW,              /// 32-bit branch
     30   RT_NoEpilogue,      /// no epilogue (fragment)
     31 };
     32 
     33 /// RuntimeFunction - An entry in the table of procedure data (.pdata)
     34 ///
     35 ///  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
     36 ///  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
     37 /// +---------------------------------------------------------------+
     38 /// |                     Function Start RVA                        |
     39 /// +-------------------+-+-+-+-----+-+---+---------------------+---+
     40 /// |    Stack Adjust   |C|L|R| Reg |H|Ret|   Function Length   |Flg|
     41 /// +-------------------+-+-+-+-----+-+---+---------------------+---+
     42 ///
     43 /// Flag : 2-bit field with the following meanings:
     44 ///   - 00 = packed unwind data not used; reamining bits point to .xdata record
     45 ///   - 01 = packed unwind data
     46 ///   - 10 = packed unwind data, function assumed to have no prologue; useful
     47 ///          for function fragments that are discontiguous with the start of the
     48 ///          function
     49 ///   - 11 = reserved
     50 /// Function Length : 11-bit field providing the length of the entire function
     51 ///                   in bytes, divided by 2; if the function is greater than
     52 ///                   4KB, a full .xdata record must be used instead
     53 /// Ret : 2-bit field indicating how the function returns
     54 ///   - 00 = return via pop {pc} (the L bit must be set)
     55 ///   - 01 = return via 16-bit branch
     56 ///   - 10 = return via 32-bit branch
     57 ///   - 11 = no epilogue; useful for function fragments that may only contain a
     58 ///          prologue but the epilogue is elsewhere
     59 /// H : 1-bit flag indicating whether the function "homes" the integer parameter
     60 ///     registers (r0-r3), allocating 16-bytes on the stack
     61 /// Reg : 3-bit field indicating the index of the last saved non-volatile
     62 ///       register.  If the R bit is set to 0, then only integer registers are
     63 ///       saved (r4-rN, where N is 4 + Reg).  If the R bit is set to 1, then
     64 ///       only floating-point registers are being saved (d8-dN, where N is
     65 ///       8 + Reg).  The special case of the R bit being set to 1 and Reg equal
     66 ///       to 7 indicates that no registers are saved.
     67 /// R : 1-bit flag indicating whether the non-volatile registers are integer or
     68 ///     floating-point.  0 indicates integer, 1 indicates floating-point.  The
     69 ///     special case of the R-flag being set and Reg being set to 7 indicates
     70 ///     that no non-volatile registers are saved.
     71 /// L : 1-bit flag indicating whether the function saves/restores the link
     72 ///     register (LR)
     73 /// C : 1-bit flag indicating whether the function includes extra instructions
     74 ///     to setup a frame chain for fast walking.  If this flag is set, r11 is
     75 ///     implicitly added to the list of saved non-volatile integer registers.
     76 /// Stack Adjust : 10-bit field indicating the number of bytes of stack that are
     77 ///                allocated for this function.  Only values between 0x000 and
     78 ///                0x3f3 can be directly encoded.  If the value is 0x3f4 or
     79 ///                greater, then the low 4 bits have special meaning as follows:
     80 ///                - Bit 0-1
     81 ///                  indicate the number of words' of adjustment (1-4), minus 1
     82 ///                - Bit 2
     83 ///                  indicates if the prologue combined adjustment into push
     84 ///                - Bit 3
     85 ///                  indicates if the epilogue combined adjustment into pop
     86 ///
     87 /// RESTRICTIONS:
     88 ///   - IF C is SET:
     89 ///     + L flag must be set since frame chaining requires r11 and lr
     90 ///     + r11 must NOT be included in the set of registers described by Reg
     91 ///   - IF Ret is 0:
     92 ///     + L flag must be set
     93 
     94 // NOTE: RuntimeFunction is meant to be a simple class that provides raw access
     95 // to all fields in the structure.  The accessor methods reflect the names of
     96 // the bitfields that they correspond to.  Although some obvious simplifications
     97 // are possible via merging of methods, it would prevent the use of this class
     98 // to fully inspect the contents of the data structure which is particularly
     99 // useful for scenarios such as llvm-readobj to aid in testing.
    100 
    101 class RuntimeFunction {
    102 public:
    103   const support::ulittle32_t BeginAddress;
    104   const support::ulittle32_t UnwindData;
    105 
    106   RuntimeFunction(const support::ulittle32_t *Data)
    107     : BeginAddress(Data[0]), UnwindData(Data[1]) {}
    108 
    109   RuntimeFunction(const support::ulittle32_t BeginAddress,
    110                   const support::ulittle32_t UnwindData)
    111     : BeginAddress(BeginAddress), UnwindData(UnwindData) {}
    112 
    113   RuntimeFunctionFlag Flag() const {
    114     return RuntimeFunctionFlag(UnwindData & 0x3);
    115   }
    116 
    117   uint32_t ExceptionInformationRVA() const {
    118     assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
    119            "unpacked form required for this operation");
    120     return (UnwindData & ~0x3);
    121   }
    122 
    123   uint32_t PackedUnwindData() const {
    124     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    125             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    126            "packed form required for this operation");
    127     return (UnwindData & ~0x3);
    128   }
    129   uint32_t FunctionLength() const {
    130     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    131             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    132            "packed form required for this operation");
    133     return (((UnwindData & 0x00001ffc) >> 2) << 1);
    134   }
    135   ReturnType Ret() const {
    136     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    137             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    138            "packed form required for this operation");
    139     assert(((UnwindData & 0x00006000) || L()) && "L must be set to 1");
    140     return ReturnType((UnwindData & 0x00006000) >> 13);
    141   }
    142   bool H() const {
    143     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    144             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    145            "packed form required for this operation");
    146     return ((UnwindData & 0x00008000) >> 15);
    147   }
    148   uint8_t Reg() const {
    149     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    150             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    151            "packed form required for this operation");
    152     return ((UnwindData & 0x00070000) >> 16);
    153   }
    154   bool R() const {
    155     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    156             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    157            "packed form required for this operation");
    158     return ((UnwindData & 0x00080000) >> 19);
    159   }
    160   bool L() const {
    161     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    162             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    163            "packed form required for this operation");
    164     return ((UnwindData & 0x00100000) >> 20);
    165   }
    166   bool C() const {
    167     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    168             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    169            "packed form required for this operation");
    170     assert(((~UnwindData & 0x00200000) || L()) &&
    171            "L flag must be set, chaining requires r11 and LR");
    172     assert(((~UnwindData & 0x00200000) || (Reg() < 7) || R()) &&
    173            "r11 must not be included in Reg; C implies r11");
    174     return ((UnwindData & 0x00200000) >> 21);
    175   }
    176   uint16_t StackAdjust() const {
    177     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
    178             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
    179            "packed form required for this operation");
    180     return ((UnwindData & 0xffc00000) >> 22);
    181   }
    182 };
    183 
    184 /// PrologueFolding - pseudo-flag derived from Stack Adjust indicating that the
    185 /// prologue has stack adjustment combined into the push
    186 inline bool PrologueFolding(const RuntimeFunction &RF) {
    187   return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x4);
    188 }
    189 /// Epilogue - pseudo-flag derived from Stack Adjust indicating that the
    190 /// epilogue has stack adjustment combined into the pop
    191 inline bool EpilogueFolding(const RuntimeFunction &RF) {
    192   return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x8);
    193 }
    194 /// StackAdjustment - calculated stack adjustment in words.  The stack
    195 /// adjustment should be determined via this function to account for the special
    196 /// handling the special encoding when the value is >= 0x3f4.
    197 inline uint16_t StackAdjustment(const RuntimeFunction &RF) {
    198   uint16_t Adjustment = RF.StackAdjust();
    199   if (Adjustment >= 0x3f4)
    200     return (Adjustment & 0x3) ? ((Adjustment & 0x3) << 2) - 1 : 0;
    201   return Adjustment;
    202 }
    203 
    204 /// SavedRegisterMask - Utility function to calculate the set of saved general
    205 /// purpose (r0-r15) and VFP (d0-d31) registers.
    206 std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF);
    207 
    208 /// ExceptionDataRecord - An entry in the table of exception data (.xdata)
    209 ///
    210 ///  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
    211 ///  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
    212 /// +-------+---------+-+-+-+---+-----------------------------------+
    213 /// | C Wrd | Epi Cnt |F|E|X|Ver|         Function Length           |
    214 /// +-------+--------+'-'-'-'---'---+-------------------------------+
    215 /// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
    216 /// +-------+--------+--------------+-------------------------------+
    217 ///
    218 /// Function Length : 18-bit field indicating the total length of the function
    219 ///                   in bytes divided by 2.  If a function is larger than
    220 ///                   512KB, then multiple pdata and xdata records must be used.
    221 /// Vers : 2-bit field describing the version of the remaining structure.  Only
    222 ///        version 0 is currently defined (values 1-3 are not permitted).
    223 /// X : 1-bit field indicating the presence of exception data
    224 /// E : 1-bit field indicating that the single epilogue is packed into the
    225 ///     header
    226 /// F : 1-bit field indicating that the record describes a function fragment
    227 ///     (implies that no prologue is present, and prologue processing should be
    228 ///     skipped)
    229 /// Epilogue Count : 5-bit field that differs in meaning based on the E field.
    230 ///
    231 ///                  If E is set, then this field specifies the index of the
    232 ///                  first unwind code describing the (only) epilogue.
    233 ///
    234 ///                  Otherwise, this field indicates the number of exception
    235 ///                  scopes.  If more than 31 scopes exist, then this field and
    236 ///                  the Code Words field must both be set to 0 to indicate that
    237 ///                  an extension word is required.
    238 /// Code Words : 4-bit field that species the number of 32-bit words needed to
    239 ///              contain all the unwind codes.  If more than 15 words (63 code
    240 ///              bytes) are required, then this field and the Epilogue Count
    241 ///              field must both be set to 0 to indicate that an extension word
    242 ///              is required.
    243 /// Extended Epilogue Count, Extended Code Words :
    244 ///                          Valid only if Epilog Count and Code Words are both
    245 ///                          set to 0.  Provides an 8-bit extended code word
    246 ///                          count and 16-bits for epilogue count
    247 ///
    248 ///  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
    249 ///  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
    250 /// +----------------+------+---+---+-------------------------------+
    251 /// |  Ep Start Idx  | Cond |Res|       Epilogue Start Offset       |
    252 /// +----------------+------+---+-----------------------------------+
    253 ///
    254 /// If the E bit is unset in the header, the header is followed by a series of
    255 /// epilogue scopes, which are sorted by their offset.
    256 ///
    257 /// Epilogue Start Offset: 18-bit field encoding the offset of epilogue relative
    258 ///                        to the start of the function in bytes divided by two
    259 /// Res : 2-bit field reserved for future expansion (must be set to 0)
    260 /// Condition : 4-bit field providing the condition under which the epilogue is
    261 ///             executed.  Unconditional epilogues should set this field to 0xe.
    262 ///             Epilogues must be entirely conditional or unconditional, and in
    263 ///             Thumb-2 mode.  The epilogue beings with the first instruction
    264 ///             after the IT opcode.
    265 /// Epilogue Start Index : 8-bit field indicating the byte index of the first
    266 ///                        unwind code describing the epilogue
    267 ///
    268 ///  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
    269 ///  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
    270 /// +---------------+---------------+---------------+---------------+
    271 /// | Unwind Code 3 | Unwind Code 2 | Unwind Code 1 | Unwind Code 0 |
    272 /// +---------------+---------------+---------------+---------------+
    273 ///
    274 /// Following the epilogue scopes, the byte code describing the unwinding
    275 /// follows.  This is padded to align up to word alignment.  Bytes are stored in
    276 /// little endian.
    277 ///
    278 ///  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
    279 ///  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
    280 /// +---------------------------------------------------------------+
    281 /// |           Exception Handler RVA (requires X = 1)              |
    282 /// +---------------------------------------------------------------+
    283 /// |  (possibly followed by data required for exception handler)   |
    284 /// +---------------------------------------------------------------+
    285 ///
    286 /// If the X bit is set in the header, the unwind byte code is followed by the
    287 /// exception handler information.  This constants of one Exception Handler RVA
    288 /// which is the address to the exception handler, followed immediately by the
    289 /// variable length data associated with the exception handler.
    290 ///
    291 
    292 struct EpilogueScope {
    293   const support::ulittle32_t ES;
    294 
    295   EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
    296   uint32_t EpilogueStartOffset() const {
    297     return (ES & 0x0003ffff);
    298   }
    299   uint8_t Res() const {
    300     return ((ES & 0x000c0000) >> 18);
    301   }
    302   uint8_t Condition() const {
    303     return ((ES & 0x00f00000) >> 20);
    304   }
    305   uint8_t EpilogueStartIndex() const {
    306     return ((ES & 0xff000000) >> 24);
    307   }
    308 };
    309 
    310 struct ExceptionDataRecord;
    311 inline size_t HeaderWords(const ExceptionDataRecord &XR);
    312 
    313 struct ExceptionDataRecord {
    314   const support::ulittle32_t *Data;
    315 
    316   ExceptionDataRecord(const support::ulittle32_t *Data) : Data(Data) {}
    317 
    318   uint32_t FunctionLength() const {
    319     return (Data[0] & 0x0003ffff);
    320   }
    321 
    322   uint8_t Vers() const {
    323     return (Data[0] & 0x000C0000) >> 18;
    324   }
    325 
    326   bool X() const {
    327     return ((Data[0] & 0x00100000) >> 20);
    328   }
    329 
    330   bool E() const {
    331     return ((Data[0] & 0x00200000) >> 21);
    332   }
    333 
    334   bool F() const {
    335     return ((Data[0] & 0x00400000) >> 22);
    336   }
    337 
    338   uint8_t EpilogueCount() const {
    339     if (HeaderWords(*this) == 1)
    340       return (Data[0] & 0x0f800000) >> 23;
    341     return Data[1] & 0x0000ffff;
    342   }
    343 
    344   uint8_t CodeWords() const {
    345     if (HeaderWords(*this) == 1)
    346       return (Data[0] & 0xf0000000) >> 28;
    347     return (Data[1] & 0x00ff0000) >> 16;
    348   }
    349 
    350   ArrayRef<support::ulittle32_t> EpilogueScopes() const {
    351     assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
    352     size_t Offset = HeaderWords(*this);
    353     return ArrayRef<support::ulittle32_t>(&Data[Offset], EpilogueCount());
    354   }
    355 
    356   ArrayRef<support::ulittle8_t> UnwindByteCode() const {
    357     const size_t Offset = HeaderWords(*this)
    358                         + (E() ? 0 :  EpilogueCount());
    359     const support::ulittle8_t *ByteCode =
    360       reinterpret_cast<const support::ulittle8_t *>(&Data[Offset]);
    361     return ArrayRef<support::ulittle8_t>(ByteCode,
    362                                          CodeWords() * sizeof(uint32_t));
    363   }
    364 
    365   uint32_t ExceptionHandlerRVA() const {
    366     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
    367     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords()];
    368   }
    369 
    370   uint32_t ExceptionHandlerParameter() const {
    371     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
    372     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1];
    373   }
    374 };
    375 
    376 inline size_t HeaderWords(const ExceptionDataRecord &XR) {
    377   return (XR.Data[0] & 0xff800000) ? 1 : 2;
    378 }
    379 }
    380 }
    381 }
    382 
    383 #endif
    384 
    385