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 : BeginAddress(Data[0]), UnwindData(Data[1]) {} 108 109 RuntimeFunction(const support::ulittle32_t BeginAddress, 110 const support::ulittle32_t UnwindData) 111 : BeginAddress(BeginAddress), UnwindData(UnwindData) {} 112 113 RuntimeFunctionFlag Flag() const { 114 return RuntimeFunctionFlag(UnwindData & 0x3); 115 } 116 117 uint32_t ExceptionInformationRVA() const { 118 assert(Flag() == RuntimeFunctionFlag::RFF_Unpacked && 119 "unpacked form required for this operation"); 120 return (UnwindData & ~0x3); 121 } 122 123 uint32_t PackedUnwindData() const { 124 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 125 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 126 "packed form required for this operation"); 127 return (UnwindData & ~0x3); 128 } 129 uint32_t FunctionLength() const { 130 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 131 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 132 "packed form required for this operation"); 133 return (((UnwindData & 0x00001ffc) >> 2) << 1); 134 } 135 ReturnType Ret() const { 136 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 137 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 138 "packed form required for this operation"); 139 assert(((UnwindData & 0x00006000) || L()) && "L must be set to 1"); 140 return ReturnType((UnwindData & 0x00006000) >> 13); 141 } 142 bool H() const { 143 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 144 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 145 "packed form required for this operation"); 146 return ((UnwindData & 0x00008000) >> 15); 147 } 148 uint8_t Reg() const { 149 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 150 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 151 "packed form required for this operation"); 152 return ((UnwindData & 0x00070000) >> 16); 153 } 154 bool R() const { 155 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 156 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 157 "packed form required for this operation"); 158 return ((UnwindData & 0x00080000) >> 19); 159 } 160 bool L() const { 161 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 162 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 163 "packed form required for this operation"); 164 return ((UnwindData & 0x00100000) >> 20); 165 } 166 bool C() const { 167 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 168 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 169 "packed form required for this operation"); 170 assert(((~UnwindData & 0x00200000) || L()) && 171 "L flag must be set, chaining requires r11 and LR"); 172 assert(((~UnwindData & 0x00200000) || (Reg() < 7) || R()) && 173 "r11 must not be included in Reg; C implies r11"); 174 return ((UnwindData & 0x00200000) >> 21); 175 } 176 uint16_t StackAdjust() const { 177 assert((Flag() == RuntimeFunctionFlag::RFF_Packed || 178 Flag() == RuntimeFunctionFlag::RFF_PackedFragment) && 179 "packed form required for this operation"); 180 return ((UnwindData & 0xffc00000) >> 22); 181 } 182 }; 183 184 /// PrologueFolding - pseudo-flag derived from Stack Adjust indicating that the 185 /// prologue has stack adjustment combined into the push 186 inline bool PrologueFolding(const RuntimeFunction &RF) { 187 return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x4); 188 } 189 /// Epilogue - pseudo-flag derived from Stack Adjust indicating that the 190 /// epilogue has stack adjustment combined into the pop 191 inline bool EpilogueFolding(const RuntimeFunction &RF) { 192 return RF.StackAdjust() >= 0x3f4 && (RF.StackAdjust() & 0x8); 193 } 194 /// StackAdjustment - calculated stack adjustment in words. The stack 195 /// adjustment should be determined via this function to account for the special 196 /// handling the special encoding when the value is >= 0x3f4. 197 inline uint16_t StackAdjustment(const RuntimeFunction &RF) { 198 uint16_t Adjustment = RF.StackAdjust(); 199 if (Adjustment >= 0x3f4) 200 return (Adjustment & 0x3) ? ((Adjustment & 0x3) << 2) - 1 : 0; 201 return Adjustment; 202 } 203 204 /// SavedRegisterMask - Utility function to calculate the set of saved general 205 /// purpose (r0-r15) and VFP (d0-d31) registers. 206 std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF); 207 208 /// ExceptionDataRecord - An entry in the table of exception data (.xdata) 209 /// 210 /// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 211 /// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 212 /// +-------+---------+-+-+-+---+-----------------------------------+ 213 /// | C Wrd | Epi Cnt |F|E|X|Ver| Function Length | 214 /// +-------+--------+'-'-'-'---'---+-------------------------------+ 215 /// | Reserved |Ex. Code Words| (Extended Epilogue Count) | 216 /// +-------+--------+--------------+-------------------------------+ 217 /// 218 /// Function Length : 18-bit field indicating the total length of the function 219 /// in bytes divided by 2. If a function is larger than 220 /// 512KB, then multiple pdata and xdata records must be used. 221 /// Vers : 2-bit field describing the version of the remaining structure. Only 222 /// version 0 is currently defined (values 1-3 are not permitted). 223 /// X : 1-bit field indicating the presence of exception data 224 /// E : 1-bit field indicating that the single epilogue is packed into the 225 /// header 226 /// F : 1-bit field indicating that the record describes a function fragment 227 /// (implies that no prologue is present, and prologue processing should be 228 /// skipped) 229 /// Epilogue Count : 5-bit field that differs in meaning based on the E field. 230 /// 231 /// If E is set, then this field specifies the index of the 232 /// first unwind code describing the (only) epilogue. 233 /// 234 /// Otherwise, this field indicates the number of exception 235 /// scopes. If more than 31 scopes exist, then this field and 236 /// the Code Words field must both be set to 0 to indicate that 237 /// an extension word is required. 238 /// Code Words : 4-bit field that species the number of 32-bit words needed to 239 /// contain all the unwind codes. If more than 15 words (63 code 240 /// bytes) are required, then this field and the Epilogue Count 241 /// field must both be set to 0 to indicate that an extension word 242 /// is required. 243 /// Extended Epilogue Count, Extended Code Words : 244 /// Valid only if Epilog Count and Code Words are both 245 /// set to 0. Provides an 8-bit extended code word 246 /// count and 16-bits for epilogue count 247 /// 248 /// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 249 /// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 250 /// +----------------+------+---+---+-------------------------------+ 251 /// | Ep Start Idx | Cond |Res| Epilogue Start Offset | 252 /// +----------------+------+---+-----------------------------------+ 253 /// 254 /// If the E bit is unset in the header, the header is followed by a series of 255 /// epilogue scopes, which are sorted by their offset. 256 /// 257 /// Epilogue Start Offset: 18-bit field encoding the offset of epilogue relative 258 /// to the start of the function in bytes divided by two 259 /// Res : 2-bit field reserved for future expansion (must be set to 0) 260 /// Condition : 4-bit field providing the condition under which the epilogue is 261 /// executed. Unconditional epilogues should set this field to 0xe. 262 /// Epilogues must be entirely conditional or unconditional, and in 263 /// Thumb-2 mode. The epilogue beings with the first instruction 264 /// after the IT opcode. 265 /// Epilogue Start Index : 8-bit field indicating the byte index of the first 266 /// unwind code describing the epilogue 267 /// 268 /// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 269 /// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 270 /// +---------------+---------------+---------------+---------------+ 271 /// | Unwind Code 3 | Unwind Code 2 | Unwind Code 1 | Unwind Code 0 | 272 /// +---------------+---------------+---------------+---------------+ 273 /// 274 /// Following the epilogue scopes, the byte code describing the unwinding 275 /// follows. This is padded to align up to word alignment. Bytes are stored in 276 /// little endian. 277 /// 278 /// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 279 /// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 280 /// +---------------------------------------------------------------+ 281 /// | Exception Handler RVA (requires X = 1) | 282 /// +---------------------------------------------------------------+ 283 /// | (possibly followed by data required for exception handler) | 284 /// +---------------------------------------------------------------+ 285 /// 286 /// If the X bit is set in the header, the unwind byte code is followed by the 287 /// exception handler information. This constants of one Exception Handler RVA 288 /// which is the address to the exception handler, followed immediately by the 289 /// variable length data associated with the exception handler. 290 /// 291 292 struct EpilogueScope { 293 const support::ulittle32_t ES; 294 295 EpilogueScope(const support::ulittle32_t Data) : ES(Data) {} 296 uint32_t EpilogueStartOffset() const { 297 return (ES & 0x0003ffff); 298 } 299 uint8_t Res() const { 300 return ((ES & 0x000c0000) >> 18); 301 } 302 uint8_t Condition() const { 303 return ((ES & 0x00f00000) >> 20); 304 } 305 uint8_t EpilogueStartIndex() const { 306 return ((ES & 0xff000000) >> 24); 307 } 308 }; 309 310 struct ExceptionDataRecord; 311 inline size_t HeaderWords(const ExceptionDataRecord &XR); 312 313 struct ExceptionDataRecord { 314 const support::ulittle32_t *Data; 315 316 ExceptionDataRecord(const support::ulittle32_t *Data) : Data(Data) {} 317 318 uint32_t FunctionLength() const { 319 return (Data[0] & 0x0003ffff); 320 } 321 322 uint8_t Vers() const { 323 return (Data[0] & 0x000C0000) >> 18; 324 } 325 326 bool X() const { 327 return ((Data[0] & 0x00100000) >> 20); 328 } 329 330 bool E() const { 331 return ((Data[0] & 0x00200000) >> 21); 332 } 333 334 bool F() const { 335 return ((Data[0] & 0x00400000) >> 22); 336 } 337 338 uint8_t EpilogueCount() const { 339 if (HeaderWords(*this) == 1) 340 return (Data[0] & 0x0f800000) >> 23; 341 return Data[1] & 0x0000ffff; 342 } 343 344 uint8_t CodeWords() const { 345 if (HeaderWords(*this) == 1) 346 return (Data[0] & 0xf0000000) >> 28; 347 return (Data[1] & 0x00ff0000) >> 16; 348 } 349 350 ArrayRef<support::ulittle32_t> EpilogueScopes() const { 351 assert(E() == 0 && "epilogue scopes are only present when the E bit is 0"); 352 size_t Offset = HeaderWords(*this); 353 return makeArrayRef(&Data[Offset], EpilogueCount()); 354 } 355 356 ArrayRef<uint8_t> UnwindByteCode() const { 357 const size_t Offset = HeaderWords(*this) 358 + (E() ? 0 : EpilogueCount()); 359 const uint8_t *ByteCode = 360 reinterpret_cast<const uint8_t *>(&Data[Offset]); 361 return makeArrayRef(ByteCode, CodeWords() * sizeof(uint32_t)); 362 } 363 364 uint32_t ExceptionHandlerRVA() const { 365 assert(X() && "Exception Handler RVA is only valid if the X bit is set"); 366 return Data[HeaderWords(*this) + EpilogueCount() + CodeWords()]; 367 } 368 369 uint32_t ExceptionHandlerParameter() const { 370 assert(X() && "Exception Handler RVA is only valid if the X bit is set"); 371 return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1]; 372 } 373 }; 374 375 inline size_t HeaderWords(const ExceptionDataRecord &XR) { 376 return (XR.Data[0] & 0xff800000) ? 1 : 2; 377 } 378 } 379 } 380 } 381 382 #endif 383
