contrib/llvm/include/llvm/Support/Win64EH.h

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