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