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
24namespace llvm {
25
26class AllocaInst;
27class BasicBlock;
28class FuncletPadInst;
29class Function;
30class GlobalVariable;
31class Instruction;
32class InvokeInst;
33class MachineBasicBlock;
34class MCSymbol;
35
36// The following structs respresent the .xdata tables for various
37// Windows-related EH personalities.
38
39using MBBOrBasicBlock = PointerUnion<const BasicBlock *, MachineBasicBlock *>;
40
41struct CxxUnwindMapEntry {
42  int ToState;
43  MBBOrBasicBlock Cleanup;
44};
45
46/// Similar to CxxUnwindMapEntry, but supports SEH filters.
47struct 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
61struct 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
73struct WinEHTryBlockMapEntry {
74  int TryLow = -1;
75  int TryHigh = -1;
76  int CatchHigh = -1;
77  SmallVector<WinEHHandlerType, 1> HandlerArray;
78};
79
80enum class ClrHandlerType { Catch, Finally, Fault, Filter };
81
82struct 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
91struct 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.
119void calculateWinCXXEHStateNumbers(const Function *ParentFn,
120                                   WinEHFuncInfo &FuncInfo);
121
122void calculateSEHStateNumbers(const Function *ParentFn,
123                              WinEHFuncInfo &FuncInfo);
124
125void calculateClrEHStateNumbers(const Function *Fn, WinEHFuncInfo &FuncInfo);
126
127} // end namespace llvm
128
129#endif // LLVM_CODEGEN_WINEHFUNCINFO_H
130