1 //===- llvm/CodeGen/WinEHFuncInfo.h -----------------------------*- 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 // Data structures and associated state for Windows exception handling schemes. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CODEGEN_WINEHFUNCINFO_H 15 #define LLVM_CODEGEN_WINEHFUNCINFO_H 16 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/ADT/PointerUnion.h" 19 #include "llvm/ADT/SmallVector.h" 20 #include <cstdint> 21 #include <limits> 22 #include <utility> 23 24 namespace llvm { 25 26 class AllocaInst; 27 class BasicBlock; 28 class FuncletPadInst; 29 class Function; 30 class GlobalVariable; 31 class Instruction; 32 class InvokeInst; 33 class MachineBasicBlock; 34 class MCSymbol; 35 36 // The following structs respresent the .xdata tables for various 37 // Windows-related EH personalities. 38 39 using MBBOrBasicBlock = PointerUnion<const BasicBlock *, MachineBasicBlock *>; 40 41 struct CxxUnwindMapEntry { 42 int ToState; 43 MBBOrBasicBlock Cleanup; 44 }; 45 46 /// Similar to CxxUnwindMapEntry, but supports SEH filters. 47 struct SEHUnwindMapEntry { 48 /// If unwinding continues through this handler, transition to the handler at 49 /// this state. This indexes into SEHUnwindMap. 50 int ToState = -1; 51 52 bool IsFinally = false; 53 54 /// Holds the filter expression function. 55 const Function *Filter = nullptr; 56 57 /// Holds the __except or __finally basic block. 58 MBBOrBasicBlock Handler; 59 }; 60 61 struct WinEHHandlerType { 62 int Adjectives; 63 /// The CatchObj starts out life as an LLVM alloca and is eventually turned 64 /// frame index. 65 union { 66 const AllocaInst *Alloca; 67 int FrameIndex; 68 } CatchObj = {}; 69 GlobalVariable *TypeDescriptor; 70 MBBOrBasicBlock Handler; 71 }; 72 73 struct WinEHTryBlockMapEntry { 74 int TryLow = -1; 75 int TryHigh = -1; 76 int CatchHigh = -1; 77 SmallVector<WinEHHandlerType, 1> HandlerArray; 78 }; 79 80 enum class ClrHandlerType { Catch, Finally, Fault, Filter }; 81 82 struct ClrEHUnwindMapEntry { 83 MBBOrBasicBlock Handler; 84 uint32_t TypeToken; 85 int HandlerParentState; ///< Outer handler enclosing this entry's handler 86 int TryParentState; ///< Outer try region enclosing this entry's try region, 87 ///< treating later catches on same try as "outer" 88 ClrHandlerType HandlerType; 89 }; 90 91 struct WinEHFuncInfo { 92 DenseMap<const Instruction *, int> EHPadStateMap; 93 DenseMap<const FuncletPadInst *, int> FuncletBaseStateMap; 94 DenseMap<const InvokeInst *, int> InvokeStateMap; 95 DenseMap<MCSymbol *, std::pair<int, MCSymbol *>> LabelToStateMap; 96 SmallVector<CxxUnwindMapEntry, 4> CxxUnwindMap; 97 SmallVector<WinEHTryBlockMapEntry, 4> TryBlockMap; 98 SmallVector<SEHUnwindMapEntry, 4> SEHUnwindMap; 99 SmallVector<ClrEHUnwindMapEntry, 4> ClrEHUnwindMap; 100 int UnwindHelpFrameIdx = std::numeric_limits<int>::max(); 101 int PSPSymFrameIdx = std::numeric_limits<int>::max(); 102 103 int getLastStateNumber() const { return CxxUnwindMap.size() - 1; } 104 105 void addIPToStateRange(const InvokeInst *II, MCSymbol *InvokeBegin, 106 MCSymbol *InvokeEnd); 107 108 int EHRegNodeFrameIndex = std::numeric_limits<int>::max(); 109 int EHRegNodeEndOffset = std::numeric_limits<int>::max(); 110 int EHGuardFrameIndex = std::numeric_limits<int>::max(); 111 int SEHSetFrameOffset = std::numeric_limits<int>::max(); 112 113 WinEHFuncInfo(); 114 }; 115 116 /// Analyze the IR in ParentFn and it's handlers to build WinEHFuncInfo, which 117 /// describes the state numbers and tables used by __CxxFrameHandler3. This 118 /// analysis assumes that WinEHPrepare has already been run. 119 void calculateWinCXXEHStateNumbers(const Function *ParentFn, 120 WinEHFuncInfo &FuncInfo); 121 122 void calculateSEHStateNumbers(const Function *ParentFn, 123 WinEHFuncInfo &FuncInfo); 124 125 void calculateClrEHStateNumbers(const Function *Fn, WinEHFuncInfo &FuncInfo); 126 127 } // end namespace llvm 128 129 #endif // LLVM_CODEGEN_WINEHFUNCINFO_H 130