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