LCOV - code coverage report
Current view: top level - include/llvm/Support - ARMWinEH.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 0 44 0.0 %
Date: 2017-09-14 15:23:50 Functions: 0 3 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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_ARMWINEH_H
      11             : #define LLVM_SUPPORT_ARMWINEH_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           0 :     : 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           0 :     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           0 :     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           0 :     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           0 :     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           0 :     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           0 :     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           0 :     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           0 :     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           0 :     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           0 :     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           0 :   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           0 :   uint16_t Adjustment = RF.StackAdjust();
     199           0 :   if (Adjustment >= 0x3f4)
     200           0 :     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           0 :   EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
     296             :   uint32_t EpilogueStartOffset() const {
     297           0 :     return (ES & 0x0003ffff);
     298             :   }
     299             :   uint8_t Res() const {
     300             :     return ((ES & 0x000c0000) >> 18);
     301             :   }
     302             :   uint8_t Condition() const {
     303           0 :     return ((ES & 0x00f00000) >> 20);
     304             :   }
     305             :   uint8_t EpilogueStartIndex() const {
     306           0 :     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           0 :   ExceptionDataRecord(const support::ulittle32_t *Data) : Data(Data) {}
     317             : 
     318             :   uint32_t FunctionLength() const {
     319           0 :     return (Data[0] & 0x0003ffff);
     320             :   }
     321             : 
     322             :   uint8_t Vers() const {
     323           0 :     return (Data[0] & 0x000C0000) >> 18;
     324             :   }
     325             : 
     326             :   bool X() const {
     327           0 :     return ((Data[0] & 0x00100000) >> 20);
     328             :   }
     329             : 
     330             :   bool E() const {
     331           0 :     return ((Data[0] & 0x00200000) >> 21);
     332             :   }
     333             : 
     334             :   bool F() const {
     335           0 :     return ((Data[0] & 0x00400000) >> 22);
     336             :   }
     337             : 
     338             :   uint8_t EpilogueCount() const {
     339           0 :     if (HeaderWords(*this) == 1)
     340           0 :       return (Data[0] & 0x0f800000) >> 23;
     341           0 :     return Data[1] & 0x0000ffff;
     342             :   }
     343             : 
     344             :   uint8_t CodeWords() const {
     345           0 :     if (HeaderWords(*this) == 1)
     346           0 :       return (Data[0] & 0xf0000000) >> 28;
     347           0 :     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           0 :     size_t Offset = HeaderWords(*this);
     353           0 :     return makeArrayRef(&Data[Offset], EpilogueCount());
     354             :   }
     355             : 
     356           0 :   ArrayRef<uint8_t> UnwindByteCode() const {
     357           0 :     const size_t Offset = HeaderWords(*this)
     358           0 :                         + (E() ? 0 :  EpilogueCount());
     359           0 :     const uint8_t *ByteCode =
     360           0 :       reinterpret_cast<const uint8_t *>(&Data[Offset]);
     361           0 :     return makeArrayRef(ByteCode, CodeWords() * sizeof(uint32_t));
     362             :   }
     363             : 
     364           0 :   uint32_t ExceptionHandlerRVA() const {
     365             :     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
     366           0 :     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords()];
     367             :   }
     368             : 
     369           0 :   uint32_t ExceptionHandlerParameter() const {
     370             :     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
     371           0 :     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1];
     372             :   }
     373             : };
     374             : 
     375             : inline size_t HeaderWords(const ExceptionDataRecord &XR) {
     376           0 :   return (XR.Data[0] & 0xff800000) ? 1 : 2;
     377             : }
     378             : }
     379             : }
     380             : }
     381             : 
     382             : #endif

Generated by: LCOV version 1.13