Line data    Source code

       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           0 :   uint8_t getUnwindOp() const {
      49          57 :     return u.UnwindOpAndOpInfo & 0x0F;
      50             :   }
      51           0 :   uint8_t getOpInfo() const {
      52          15 :     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           0 :   uint8_t getVersion() const {
      84          19 :     return VersionAndFlags & 0x07;
      85             :   }
      86           0 :   uint8_t getFlags() const {
      87          32 :     return (VersionAndFlags >> 3) & 0x1f;
      88             :   }
      89           0 :   uint8_t getFrameRegister() const {
      90          24 :     return FrameRegisterAndOffset & 0x0f;
      91             :   }
      92           0 :   uint8_t getFrameOffset() const {
      93           5 :     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             :   /// Return pointer to language specific data part of UnwindInfo.
     105             :   void *getLanguageSpecificData() {
     106             :     return reinterpret_cast<void *>(&UnwindCodes[(NumCodes+1) & ~1]);
     107             :   }
     108             : 
     109             :   /// Return pointer to language specific data part of UnwindInfo.
     110             :   const void *getLanguageSpecificData() const {
     111           7 :     return reinterpret_cast<const void *>(&UnwindCodes[(NumCodes + 1) & ~1]);
     112             :   }
     113             : 
     114             :   /// 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             :   /// 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             :   /// Return pointer to exception-specific data.
     127             :   void *getExceptionData() {
     128             :     return reinterpret_cast<void *>(reinterpret_cast<uint32_t *>(
     129             :                                                   getLanguageSpecificData())+1);
     130             :   }
     131             : 
     132             :   /// Return pointer to chained unwind info.
     133             :   RuntimeFunction *getChainedFunctionEntry() {
     134             :     return reinterpret_cast<RuntimeFunction *>(getLanguageSpecificData());
     135             :   }
     136             : 
     137             :   /// 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