Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-- llvm/Support/ARMWinEH.h - Windows on ARM EH Constants ---*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8.  
  9. #ifndef LLVM_SUPPORT_ARMWINEH_H
  10. #define LLVM_SUPPORT_ARMWINEH_H
  11.  
  12. #include "llvm/ADT/ArrayRef.h"
  13. #include "llvm/Support/Endian.h"
  14.  
  15. namespace llvm {
  16. namespace ARM {
  17. namespace WinEH {
  18. enum class RuntimeFunctionFlag {
  19.   RFF_Unpacked,       /// unpacked entry
  20.   RFF_Packed,         /// packed entry
  21.   RFF_PackedFragment, /// packed entry representing a fragment
  22.   RFF_Reserved,       /// reserved
  23. };
  24.  
  25. enum class ReturnType {
  26.   RT_POP,             /// return via pop {pc} (L flag must be set)
  27.   RT_B,               /// 16-bit branch
  28.   RT_BW,              /// 32-bit branch
  29.   RT_NoEpilogue,      /// no epilogue (fragment)
  30. };
  31.  
  32. /// RuntimeFunction - An entry in the table of procedure data (.pdata)
  33. ///
  34. /// This is ARM specific, but the Function Start RVA, Flag and
  35. /// ExceptionInformationRVA fields work identically for ARM64.
  36. ///
  37. ///  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
  38. ///  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
  39. /// +---------------------------------------------------------------+
  40. /// |                     Function Start RVA                        |
  41. /// +-------------------+-+-+-+-----+-+---+---------------------+---+
  42. /// |    Stack Adjust   |C|L|R| Reg |H|Ret|   Function Length   |Flg|
  43. /// +-------------------+-+-+-+-----+-+---+---------------------+---+
  44. ///
  45. /// Flag : 2-bit field with the following meanings:
  46. ///   - 00 = packed unwind data not used; reamining bits point to .xdata record
  47. ///   - 01 = packed unwind data
  48. ///   - 10 = packed unwind data, function assumed to have no prologue; useful
  49. ///          for function fragments that are discontiguous with the start of the
  50. ///          function
  51. ///   - 11 = reserved
  52. /// Function Length : 11-bit field providing the length of the entire function
  53. ///                   in bytes, divided by 2; if the function is greater than
  54. ///                   4KB, a full .xdata record must be used instead
  55. /// Ret : 2-bit field indicating how the function returns
  56. ///   - 00 = return via pop {pc} (the L bit must be set)
  57. ///   - 01 = return via 16-bit branch
  58. ///   - 10 = return via 32-bit branch
  59. ///   - 11 = no epilogue; useful for function fragments that may only contain a
  60. ///          prologue but the epilogue is elsewhere
  61. /// H : 1-bit flag indicating whether the function "homes" the integer parameter
  62. ///     registers (r0-r3), allocating 16-bytes on the stack
  63. /// Reg : 3-bit field indicating the index of the last saved non-volatile
  64. ///       register.  If the R bit is set to 0, then only integer registers are
  65. ///       saved (r4-rN, where N is 4 + Reg).  If the R bit is set to 1, then
  66. ///       only floating-point registers are being saved (d8-dN, where N is
  67. ///       8 + Reg).  The special case of the R bit being set to 1 and Reg equal
  68. ///       to 7 indicates that no registers are saved.
  69. /// R : 1-bit flag indicating whether the non-volatile registers are integer or
  70. ///     floating-point.  0 indicates integer, 1 indicates floating-point.  The
  71. ///     special case of the R-flag being set and Reg being set to 7 indicates
  72. ///     that no non-volatile registers are saved.
  73. /// L : 1-bit flag indicating whether the function saves/restores the link
  74. ///     register (LR)
  75. /// C : 1-bit flag indicating whether the function includes extra instructions
  76. ///     to setup a frame chain for fast walking.  If this flag is set, r11 is
  77. ///     implicitly added to the list of saved non-volatile integer registers.
  78. /// Stack Adjust : 10-bit field indicating the number of bytes of stack that are
  79. ///                allocated for this function.  Only values between 0x000 and
  80. ///                0x3f3 can be directly encoded.  If the value is 0x3f4 or
  81. ///                greater, then the low 4 bits have special meaning as follows:
  82. ///                - Bit 0-1
  83. ///                  indicate the number of words' of adjustment (1-4), minus 1
  84. ///                - Bit 2
  85. ///                  indicates if the prologue combined adjustment into push
  86. ///                - Bit 3
  87. ///                  indicates if the epilogue combined adjustment into pop
  88. ///
  89. /// RESTRICTIONS:
  90. ///   - IF C is SET:
  91. ///     + L flag must be set since frame chaining requires r11 and lr
  92. ///     + r11 must NOT be included in the set of registers described by Reg
  93. ///   - IF Ret is 0:
  94. ///     + L flag must be set
  95.  
  96. // NOTE: RuntimeFunction is meant to be a simple class that provides raw access
  97. // to all fields in the structure.  The accessor methods reflect the names of
  98. // the bitfields that they correspond to.  Although some obvious simplifications
  99. // are possible via merging of methods, it would prevent the use of this class
  100. // to fully inspect the contents of the data structure which is particularly
  101. // useful for scenarios such as llvm-readobj to aid in testing.
  102.  
  103. class RuntimeFunction {
  104. public:
  105.   const support::ulittle32_t BeginAddress;
  106.   const support::ulittle32_t UnwindData;
  107.  
  108.   RuntimeFunction(const support::ulittle32_t *Data)
  109.     : BeginAddress(Data[0]), UnwindData(Data[1]) {}
  110.  
  111.   RuntimeFunction(const support::ulittle32_t BeginAddress,
  112.                   const support::ulittle32_t UnwindData)
  113.     : BeginAddress(BeginAddress), UnwindData(UnwindData) {}
  114.  
  115.   RuntimeFunctionFlag Flag() const {
  116.     return RuntimeFunctionFlag(UnwindData & 0x3);
  117.   }
  118.  
  119.   uint32_t ExceptionInformationRVA() const {
  120.     assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
  121.            "unpacked form required for this operation");
  122.     return (UnwindData & ~0x3);
  123.   }
  124.  
  125.   uint32_t PackedUnwindData() const {
  126.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  127.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  128.            "packed form required for this operation");
  129.     return (UnwindData & ~0x3);
  130.   }
  131.   uint32_t FunctionLength() const {
  132.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  133.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  134.            "packed form required for this operation");
  135.     return (((UnwindData & 0x00001ffc) >> 2) << 1);
  136.   }
  137.   ReturnType Ret() const {
  138.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  139.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  140.            "packed form required for this operation");
  141.     assert(((UnwindData & 0x00006000) || L()) && "L must be set to 1");
  142.     return ReturnType((UnwindData & 0x00006000) >> 13);
  143.   }
  144.   bool H() const {
  145.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  146.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  147.            "packed form required for this operation");
  148.     return ((UnwindData & 0x00008000) >> 15);
  149.   }
  150.   uint8_t Reg() const {
  151.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  152.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  153.            "packed form required for this operation");
  154.     return ((UnwindData & 0x00070000) >> 16);
  155.   }
  156.   bool R() const {
  157.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  158.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  159.            "packed form required for this operation");
  160.     return ((UnwindData & 0x00080000) >> 19);
  161.   }
  162.   bool L() const {
  163.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  164.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  165.            "packed form required for this operation");
  166.     return ((UnwindData & 0x00100000) >> 20);
  167.   }
  168.   bool C() const {
  169.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  170.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  171.            "packed form required for this operation");
  172.     assert(((~UnwindData & 0x00200000) || L()) &&
  173.            "L flag must be set, chaining requires r11 and LR");
  174.     assert(((~UnwindData & 0x00200000) || (Reg() < 7) || R()) &&
  175.            "r11 must not be included in Reg; C implies r11");
  176.     return ((UnwindData & 0x00200000) >> 21);
  177.   }
  178.   uint16_t StackAdjust() const {
  179.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  180.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  181.            "packed form required for this operation");
  182.     return ((UnwindData & 0xffc00000) >> 22);
  183.   }
  184. };
  185.  
  186. /// PrologueFolding - pseudo-flag derived from Stack Adjust indicating that the
  187. /// prologue has stack adjustment combined into the push
  188. inline bool PrologueFolding(const RuntimeFunction &RF) {
  189.   return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x4);
  190. }
  191. /// Epilogue - pseudo-flag derived from Stack Adjust indicating that the
  192. /// epilogue has stack adjustment combined into the pop
  193. inline bool EpilogueFolding(const RuntimeFunction &RF) {
  194.   return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x8);
  195. }
  196. /// StackAdjustment - calculated stack adjustment in words.  The stack
  197. /// adjustment should be determined via this function to account for the special
  198. /// handling the special encoding when the value is >= 0x3f4.
  199. inline uint16_t StackAdjustment(const RuntimeFunction &RF) {
  200.   uint16_t Adjustment = RF.StackAdjust();
  201.   if (Adjustment >= 0x3f4)
  202.     return (Adjustment & 0x3) + 1;
  203.   return Adjustment;
  204. }
  205.  
  206. /// SavedRegisterMask - Utility function to calculate the set of saved general
  207. /// purpose (r0-r15) and VFP (d0-d31) registers.
  208. std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF,
  209.                                                 bool Prologue = true);
  210.  
  211. /// RuntimeFunctionARM64 - An entry in the table of procedure data (.pdata)
  212. ///
  213. ///  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
  214. ///  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
  215. /// +---------------------------------------------------------------+
  216. /// |                     Function Start RVA                        |
  217. /// +-----------------+---+-+-------+-----+---------------------+---+
  218. /// |    Frame Size   |CR |H| RegI  |RegF |   Function Length   |Flg|
  219. /// +-----------------+---+-+-------+-----+---------------------+---+
  220. ///
  221. /// See https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
  222. /// for the full reference for this struct.
  223.  
  224. class RuntimeFunctionARM64 {
  225. public:
  226.   const support::ulittle32_t BeginAddress;
  227.   const support::ulittle32_t UnwindData;
  228.  
  229.   RuntimeFunctionARM64(const support::ulittle32_t *Data)
  230.       : BeginAddress(Data[0]), UnwindData(Data[1]) {}
  231.  
  232.   RuntimeFunctionARM64(const support::ulittle32_t BeginAddress,
  233.                        const support::ulittle32_t UnwindData)
  234.       : BeginAddress(BeginAddress), UnwindData(UnwindData) {}
  235.  
  236.   RuntimeFunctionFlag Flag() const {
  237.     return RuntimeFunctionFlag(UnwindData & 0x3);
  238.   }
  239.  
  240.   uint32_t ExceptionInformationRVA() const {
  241.     assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
  242.            "unpacked form required for this operation");
  243.     return (UnwindData & ~0x3);
  244.   }
  245.  
  246.   uint32_t PackedUnwindData() const {
  247.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  248.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  249.            "packed form required for this operation");
  250.     return (UnwindData & ~0x3);
  251.   }
  252.   uint32_t FunctionLength() const {
  253.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  254.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  255.            "packed form required for this operation");
  256.     return (((UnwindData & 0x00001ffc) >> 2) << 2);
  257.   }
  258.   uint8_t RegF() const {
  259.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  260.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  261.            "packed form required for this operation");
  262.     return ((UnwindData & 0x0000e000) >> 13);
  263.   }
  264.   uint8_t RegI() const {
  265.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  266.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  267.            "packed form required for this operation");
  268.     return ((UnwindData & 0x000f0000) >> 16);
  269.   }
  270.   bool H() const {
  271.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  272.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  273.            "packed form required for this operation");
  274.     return ((UnwindData & 0x00100000) >> 20);
  275.   }
  276.   uint8_t CR() const {
  277.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  278.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  279.            "packed form required for this operation");
  280.     return ((UnwindData & 0x600000) >> 21);
  281.   }
  282.   uint16_t FrameSize() const {
  283.     assert((Flag() == RuntimeFunctionFlag::RFF_Packed ||
  284.             Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
  285.            "packed form required for this operation");
  286.     return ((UnwindData & 0xff800000) >> 23);
  287.   }
  288. };
  289.  
  290. /// ExceptionDataRecord - An entry in the table of exception data (.xdata)
  291. ///
  292. /// The format on ARM is:
  293. ///
  294. ///  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
  295. ///  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
  296. /// +-------+---------+-+-+-+---+-----------------------------------+
  297. /// | C Wrd | Epi Cnt |F|E|X|Ver|         Function Length           |
  298. /// +-------+--------+'-'-'-'---'---+-------------------------------+
  299. /// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
  300. /// +-------+--------+--------------+-------------------------------+
  301. ///
  302. /// The format on ARM64 is:
  303. ///
  304. ///  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
  305. ///  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
  306. /// +---------+---------+-+-+---+-----------------------------------+
  307. /// |  C Wrd  | Epi Cnt |E|X|Ver|         Function Length           |
  308. /// +---------+------+--'-'-'---'---+-------------------------------+
  309. /// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
  310. /// +-------+--------+--------------+-------------------------------+
  311. ///
  312. /// Function Length : 18-bit field indicating the total length of the function
  313. ///                   in bytes divided by 2.  If a function is larger than
  314. ///                   512KB, then multiple pdata and xdata records must be used.
  315. /// Vers : 2-bit field describing the version of the remaining structure.  Only
  316. ///        version 0 is currently defined (values 1-3 are not permitted).
  317. /// X : 1-bit field indicating the presence of exception data
  318. /// E : 1-bit field indicating that the single epilogue is packed into the
  319. ///     header
  320. /// F : 1-bit field indicating that the record describes a function fragment
  321. ///     (implies that no prologue is present, and prologue processing should be
  322. ///     skipped) (ARM only)
  323. /// Epilogue Count : 5-bit field that differs in meaning based on the E field.
  324. ///
  325. ///                  If E is set, then this field specifies the index of the
  326. ///                  first unwind code describing the (only) epilogue.
  327. ///
  328. ///                  Otherwise, this field indicates the number of exception
  329. ///                  scopes.  If more than 31 scopes exist, then this field and
  330. ///                  the Code Words field must both be set to 0 to indicate that
  331. ///                  an extension word is required.
  332. /// Code Words : 4-bit (5-bit on ARM64) field that specifies the number of
  333. ///              32-bit words needed to contain all the unwind codes.  If more
  334. ///              than 15 words (31 words on ARM64) are required, then this field
  335. ///              and the Epilogue Count field must both be set to 0 to indicate
  336. ///              that an extension word is required.
  337. /// Extended Epilogue Count, Extended Code Words :
  338. ///                          Valid only if Epilog Count and Code Words are both
  339. ///                          set to 0.  Provides an 8-bit extended code word
  340. ///                          count and 16-bits for epilogue count
  341. ///
  342. /// The epilogue scope format on ARM is:
  343. ///
  344. ///  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
  345. ///  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
  346. /// +----------------+------+---+---+-------------------------------+
  347. /// |  Ep Start Idx  | Cond |Res|       Epilogue Start Offset       |
  348. /// +----------------+------+---+-----------------------------------+
  349. ///
  350. /// The epilogue scope format on ARM64 is:
  351. ///
  352. ///  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
  353. ///  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
  354. /// +-------------------+-------+---+-------------------------------+
  355. /// |  Ep Start Idx     |  Res  |   Epilogue Start Offset           |
  356. /// +-------------------+-------+-----------------------------------+
  357. ///
  358. /// If the E bit is unset in the header, the header is followed by a series of
  359. /// epilogue scopes, which are sorted by their offset.
  360. ///
  361. /// Epilogue Start Offset: 18-bit field encoding the offset of epilogue relative
  362. ///                        to the start of the function in bytes divided by two
  363. /// Res : 2-bit field reserved for future expansion (must be set to 0)
  364. /// Condition : (ARM only) 4-bit field providing the condition under which the
  365. ///             epilogue is executed.  Unconditional epilogues should set this
  366. ///             field to 0xe. Epilogues must be entirely conditional or
  367. ///             unconditional, and in Thumb-2 mode.  The epilogue begins with
  368. ///             the first instruction after the IT opcode.
  369. /// Epilogue Start Index : 8-bit field indicating the byte index of the first
  370. ///                        unwind code describing the epilogue
  371. ///
  372. ///  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
  373. ///  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
  374. /// +---------------+---------------+---------------+---------------+
  375. /// | Unwind Code 3 | Unwind Code 2 | Unwind Code 1 | Unwind Code 0 |
  376. /// +---------------+---------------+---------------+---------------+
  377. ///
  378. /// Following the epilogue scopes, the byte code describing the unwinding
  379. /// follows.  This is padded to align up to word alignment.  Bytes are stored in
  380. /// little endian.
  381. ///
  382. ///  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
  383. ///  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
  384. /// +---------------------------------------------------------------+
  385. /// |           Exception Handler RVA (requires X = 1)              |
  386. /// +---------------------------------------------------------------+
  387. /// |  (possibly followed by data required for exception handler)   |
  388. /// +---------------------------------------------------------------+
  389. ///
  390. /// If the X bit is set in the header, the unwind byte code is followed by the
  391. /// exception handler information.  This constants of one Exception Handler RVA
  392. /// which is the address to the exception handler, followed immediately by the
  393. /// variable length data associated with the exception handler.
  394. ///
  395.  
  396. struct EpilogueScope {
  397.   const support::ulittle32_t ES;
  398.  
  399.   EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
  400.   // Same for both ARM and AArch64.
  401.   uint32_t EpilogueStartOffset() const {
  402.     return (ES & 0x0003ffff);
  403.   }
  404.  
  405.   // Different implementations for ARM and AArch64.
  406.   uint8_t ResARM() const {
  407.     return ((ES & 0x000c0000) >> 18);
  408.   }
  409.  
  410.   uint8_t ResAArch64() const {
  411.     return ((ES & 0x000f0000) >> 18);
  412.   }
  413.  
  414.   // Condition is only applicable to ARM.
  415.   uint8_t Condition() const {
  416.     return ((ES & 0x00f00000) >> 20);
  417.   }
  418.  
  419.   // Different implementations for ARM and AArch64.
  420.   uint8_t EpilogueStartIndexARM() const {
  421.     return ((ES & 0xff000000) >> 24);
  422.   }
  423.  
  424.   uint16_t EpilogueStartIndexAArch64() const {
  425.     return ((ES & 0xffc00000) >> 22);
  426.   }
  427. };
  428.  
  429. struct ExceptionDataRecord;
  430. inline size_t HeaderWords(const ExceptionDataRecord &XR);
  431.  
  432. struct ExceptionDataRecord {
  433.   const support::ulittle32_t *Data;
  434.   bool isAArch64;
  435.  
  436.   ExceptionDataRecord(const support::ulittle32_t *Data, bool isAArch64) :
  437.     Data(Data), isAArch64(isAArch64) {}
  438.  
  439.   uint32_t FunctionLength() const {
  440.     return (Data[0] & 0x0003ffff);
  441.   }
  442.  
  443.   uint32_t FunctionLengthInBytesARM() const {
  444.     return FunctionLength() << 1;
  445.   }
  446.  
  447.   uint32_t FunctionLengthInBytesAArch64() const {
  448.     return FunctionLength() << 2;
  449.   }
  450.  
  451.   uint8_t Vers() const {
  452.     return (Data[0] & 0x000C0000) >> 18;
  453.   }
  454.  
  455.   bool X() const {
  456.     return ((Data[0] & 0x00100000) >> 20);
  457.   }
  458.  
  459.   bool E() const {
  460.     return ((Data[0] & 0x00200000) >> 21);
  461.   }
  462.  
  463.   bool F() const {
  464.     assert(!isAArch64 && "Fragments are only supported on ARMv7 WinEH");
  465.     return ((Data[0] & 0x00400000) >> 22);
  466.   }
  467.  
  468.   uint16_t EpilogueCount() const {
  469.     if (HeaderWords(*this) == 1) {
  470.       if (isAArch64)
  471.         return (Data[0] & 0x07C00000) >> 22;
  472.       return (Data[0] & 0x0f800000) >> 23;
  473.     }
  474.     return Data[1] & 0x0000ffff;
  475.   }
  476.  
  477.   uint8_t CodeWords() const {
  478.     if (HeaderWords(*this) == 1) {
  479.       if (isAArch64)
  480.         return (Data[0] & 0xf8000000) >> 27;
  481.       return (Data[0] & 0xf0000000) >> 28;
  482.     }
  483.     return (Data[1] & 0x00ff0000) >> 16;
  484.   }
  485.  
  486.   ArrayRef<support::ulittle32_t> EpilogueScopes() const {
  487.     assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
  488.     size_t Offset = HeaderWords(*this);
  489.     return ArrayRef(&Data[Offset], EpilogueCount());
  490.   }
  491.  
  492.   ArrayRef<uint8_t> UnwindByteCode() const {
  493.     const size_t Offset = HeaderWords(*this)
  494.                         + (E() ? 0 :  EpilogueCount());
  495.     const uint8_t *ByteCode =
  496.       reinterpret_cast<const uint8_t *>(&Data[Offset]);
  497.     return ArrayRef(ByteCode, CodeWords() * sizeof(uint32_t));
  498.   }
  499.  
  500.   uint32_t ExceptionHandlerRVA() const {
  501.     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
  502.     return Data[HeaderWords(*this) + (E() ? 0 : EpilogueCount()) + CodeWords()];
  503.   }
  504.  
  505.   uint32_t ExceptionHandlerParameter() const {
  506.     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
  507.     return Data[HeaderWords(*this) + (E() ? 0 : EpilogueCount()) + CodeWords() +
  508.                 1];
  509.   }
  510. };
  511.  
  512. inline size_t HeaderWords(const ExceptionDataRecord &XR) {
  513.   if (XR.isAArch64)
  514.     return (XR.Data[0] & 0xffc00000) ? 1 : 2;
  515.   return (XR.Data[0] & 0xff800000) ? 1 : 2;
  516. }
  517. }
  518. }
  519. }
  520.  
  521. #endif
  522.