include/llvm/Support/Win64EH.h

   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   void *getLanguageSpecificData() {
 122     return reinterpret_cast<void *>(&UnwindCodes[(NumCodes+1) & ~1]);
 123   }
 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   void setLanguageSpecificHandlerOffset(uint32_t offset) {
 138     *reinterpret_cast<support::ulittle32_t *>(getLanguageSpecificData()) =
 139         offset;
 140   }
 141
 142   /// Return pointer to exception-specific data.
 143   void *getExceptionData() {
 144     return reinterpret_cast<void *>(reinterpret_cast<uint32_t *>(
 145                                                   getLanguageSpecificData())+1);
 146   }
 147
 148   /// Return pointer to chained unwind info.
 149   RuntimeFunction *getChainedFunctionEntry() {
 150     return reinterpret_cast<RuntimeFunction *>(getLanguageSpecificData());
 151   }
 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