include/llvm/CodeGen/WinEHFuncInfo.h

   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