contrib/llvm/include/llvm/CodeGen/WinEHFuncInfo.h

   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