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(XR: *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(XR: *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(XR: *this); |
489 | return ArrayRef(&Data[Offset], EpilogueCount()); |
490 | } |
491 | |
492 | ArrayRef<uint8_t> UnwindByteCode() const { |
493 | const size_t Offset = HeaderWords(XR: *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(XR: *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(XR: *this) + (E() ? 0 : EpilogueCount()) + CodeWords() + |
508 | 1]; |
509 | } |
510 | }; |
511 | |
512 | inline size_t (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 | |