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