Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/Win64EH.h
Line
Count
Source (jump to first uncovered line)
1
//===-- llvm/Support/Win64EH.h ---Win64 EH Constants-------------*- 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
// This file contains constants and structures used for implementing
10
// exception handling on Win64 platforms. For more information, see
11
// http://msdn.microsoft.com/en-us/library/1eyas8tf.aspx
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_SUPPORT_WIN64EH_H
16
#define LLVM_SUPPORT_WIN64EH_H
17
18
#include "llvm/Support/DataTypes.h"
19
#include "llvm/Support/Endian.h"
20
21
namespace llvm {
22
namespace Win64EH {
23
24
/// UnwindOpcodes - Enumeration whose values specify a single operation in
25
/// the prolog of a function.
26
enum UnwindOpcodes {
27
  UOP_PushNonVol = 0,
28
  UOP_AllocLarge,
29
  UOP_AllocSmall,
30
  UOP_SetFPReg,
31
  UOP_SaveNonVol,
32
  UOP_SaveNonVolBig,
33
  UOP_SaveXMM128 = 8,
34
  UOP_SaveXMM128Big,
35
  UOP_PushMachFrame,
36
  // The following set of unwind opcodes is for ARM64.  They are documented at
37
  // https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
38
  UOP_AllocMedium,
39
  UOP_SaveFPLRX,
40
  UOP_SaveFPLR,
41
  UOP_SaveReg,
42
  UOP_SaveRegX,
43
  UOP_SaveRegP,
44
  UOP_SaveRegPX,
45
  UOP_SaveFReg,
46
  UOP_SaveFRegX,
47
  UOP_SaveFRegP,
48
  UOP_SaveFRegPX,
49
  UOP_SetFP,
50
  UOP_AddFP,
51
  UOP_Nop,
52
  UOP_End
53
};
54
55
/// UnwindCode - This union describes a single operation in a function prolog,
56
/// or part thereof.
57
union UnwindCode {
58
  struct {
59
    uint8_t CodeOffset;
60
    uint8_t UnwindOpAndOpInfo;
61
  } u;
62
  support::ulittle16_t FrameOffset;
63
64
  uint8_t getUnwindOp() const {
65
    return u.UnwindOpAndOpInfo & 0x0F;
66
  }
67
  uint8_t getOpInfo() const {
68
    return (u.UnwindOpAndOpInfo >> 4) & 0x0F;
69
  }
70
};
71
72
enum {
73
  /// UNW_ExceptionHandler - Specifies that this function has an exception
74
  /// handler.
75
  UNW_ExceptionHandler = 0x01,
76
  /// UNW_TerminateHandler - Specifies that this function has a termination
77
  /// handler.
78
  UNW_TerminateHandler = 0x02,
79
  /// UNW_ChainInfo - Specifies that this UnwindInfo structure is chained to
80
  /// another one.
81
  UNW_ChainInfo = 0x04
82
};
83
84
/// RuntimeFunction - An entry in the table of functions with unwind info.
85
struct RuntimeFunction {
86
  support::ulittle32_t StartAddress;
87
  support::ulittle32_t EndAddress;
88
  support::ulittle32_t UnwindInfoOffset;
89
};
90
91
/// UnwindInfo - An entry in the exception table.
92
struct UnwindInfo {
93
  uint8_t VersionAndFlags;
94
  uint8_t PrologSize;
95
  uint8_t NumCodes;
96
  uint8_t FrameRegisterAndOffset;
97
  UnwindCode UnwindCodes[1];
98
99
  uint8_t getVersion() const {
100
    return VersionAndFlags & 0x07;
101
  }
102
  uint8_t getFlags() const {
103
    return (VersionAndFlags >> 3) & 0x1f;
104
  }
105
  uint8_t getFrameRegister() const {
106
    return FrameRegisterAndOffset & 0x0f;
107
  }
108
  uint8_t getFrameOffset() const {
109
    return (FrameRegisterAndOffset >> 4) & 0x0f;
110
  }
111
112
  // The data after unwindCodes depends on flags.
113
  // If UNW_ExceptionHandler or UNW_TerminateHandler is set then follows
114
  // the address of the language-specific exception handler.
115
  // If UNW_ChainInfo is set then follows a RuntimeFunction which defines
116
  // the chained unwind info.
117
  // For more information please see MSDN at:
118
  // http://msdn.microsoft.com/en-us/library/ddssxxy8.aspx
119
120
  /// Return pointer to language specific data part of UnwindInfo.
121
0
  void *getLanguageSpecificData() {
122
0
    return reinterpret_cast<void *>(&UnwindCodes[(NumCodes+1) & ~1]);
123
0
  }
124
125
  /// Return pointer to language specific data part of UnwindInfo.
126
  const void *getLanguageSpecificData() const {
127
    return reinterpret_cast<const void *>(&UnwindCodes[(NumCodes + 1) & ~1]);
128
  }
129
130
  /// Return image-relative offset of language-specific exception handler.
131
  uint32_t getLanguageSpecificHandlerOffset() const {
132
    return *reinterpret_cast<const support::ulittle32_t *>(
133
               getLanguageSpecificData());
134
  }
135
136
  /// Set image-relative offset of language-specific exception handler.
137
0
  void setLanguageSpecificHandlerOffset(uint32_t offset) {
138
0
    *reinterpret_cast<support::ulittle32_t *>(getLanguageSpecificData()) =
139
0
        offset;
140
0
  }
141
142
  /// Return pointer to exception-specific data.
143
0
  void *getExceptionData() {
144
0
    return reinterpret_cast<void *>(reinterpret_cast<uint32_t *>(
145
0
                                                  getLanguageSpecificData())+1);
146
0
  }
147
148
  /// Return pointer to chained unwind info.
149
0
  RuntimeFunction *getChainedFunctionEntry() {
150
0
    return reinterpret_cast<RuntimeFunction *>(getLanguageSpecificData());
151
0
  }
152
153
  /// Return pointer to chained unwind info.
154
  const RuntimeFunction *getChainedFunctionEntry() const {
155
    return reinterpret_cast<const RuntimeFunction *>(getLanguageSpecificData());
156
  }
157
};
158
159
160
} // End of namespace Win64EH
161
} // End of namespace llvm
162
163
#endif