Home | History | Annotate | Download | only in Support 
      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
    148