Coverage Report

Created: 2019-02-21 13:17

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/WinEHFuncInfo.h
Line
Count
Source
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
313
  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