src/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 };
  38
  39 /// UnwindCode - This union describes a single operation in a function prolog,
  40 /// or part thereof.
  41 union UnwindCode {
  42   struct {
  43     uint8_t CodeOffset;
  44     uint8_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
  56 enum {
  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.
  69 struct 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.
  76 struct UnwindInfo {
  77   uint8_t VersionAndFlags;
  78   uint8_t PrologSize;
  79   uint8_t NumCodes;
  80   uint8_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