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