contrib/llvm/tools/clang/include/clang/Basic/ABI.h

   1 //===----- ABI.h - ABI related declarations ---------------------*- 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 /// \file
  11 /// Enums/classes describing ABI related information about constructors,
  12 /// destructors and thunks.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CLANG_BASIC_ABI_H
  17 #define LLVM_CLANG_BASIC_ABI_H
  18
  19 #include "llvm/Support/DataTypes.h"
  20 #include <cstring>
  21
  22 namespace clang {
  23
  24 /// C++ constructor types.
  25 enum CXXCtorType {
  26   Ctor_Complete,       ///< Complete object ctor
  27   Ctor_Base,           ///< Base object ctor
  28   Ctor_Comdat,         ///< The COMDAT used for ctors
  29   Ctor_CopyingClosure, ///< Copying closure variant of a ctor
  30   Ctor_DefaultClosure, ///< Default closure variant of a ctor
  31 };
  32
  33 /// C++ destructor types.
  34 enum CXXDtorType {
  35     Dtor_Deleting, ///< Deleting dtor
  36     Dtor_Complete, ///< Complete object dtor
  37     Dtor_Base,     ///< Base object dtor
  38     Dtor_Comdat    ///< The COMDAT used for dtors
  39 };
  40
  41 /// A return adjustment.
  42 struct ReturnAdjustment {
  43   /// The non-virtual adjustment from the derived object to its
  44   /// nearest virtual base.
  45   int64_t NonVirtual;
  46
  47   /// Holds the ABI-specific information about the virtual return
  48   /// adjustment, if needed.
  49   union VirtualAdjustment {
  50     // Itanium ABI
  51     struct {
  52       /// The offset (in bytes), relative to the address point
  53       /// of the virtual base class offset.
  54       int64_t VBaseOffsetOffset;
  55     } Itanium;
  56
  57     // Microsoft ABI
  58     struct {
  59       /// The offset (in bytes) of the vbptr, relative to the beginning
  60       /// of the derived class.
  61       uint32_t VBPtrOffset;
  62
  63       /// Index of the virtual base in the vbtable.
  64       uint32_t VBIndex;
  65     } Microsoft;
  66
  67     VirtualAdjustment() {
  68       memset(this, 0, sizeof(*this));
  69     }
  70
  71     bool Equals(const VirtualAdjustment &Other) const {
  72       return memcmp(this, &Other, sizeof(Other)) == 0;
  73     }
  74
  75     bool isEmpty() const {
  76       VirtualAdjustment Zero;
  77       return Equals(Zero);
  78     }
  79
  80     bool Less(const VirtualAdjustment &RHS) const {
  81       return memcmp(this, &RHS, sizeof(RHS)) < 0;
  82     }
  83   } Virtual;
  84
  85   ReturnAdjustment() : NonVirtual(0) {}
  86
  87   bool isEmpty() const { return !NonVirtual && Virtual.isEmpty(); }
  88
  89   friend bool operator==(const ReturnAdjustment &LHS,
  90                          const ReturnAdjustment &RHS) {
  91     return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
  92   }
  93
  94   friend bool operator!=(const ReturnAdjustment &LHS, const ReturnAdjustment &RHS) {
  95     return !(LHS == RHS);
  96   }
  97
  98   friend bool operator<(const ReturnAdjustment &LHS,
  99                         const ReturnAdjustment &RHS) {
 100     if (LHS.NonVirtual < RHS.NonVirtual)
 101       return true;
 102
 103     return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Less(RHS.Virtual);
 104   }
 105 };
 106
 107 /// A \c this pointer adjustment.
 108 struct ThisAdjustment {
 109   /// The non-virtual adjustment from the derived object to its
 110   /// nearest virtual base.
 111   int64_t NonVirtual;
 112
 113   /// Holds the ABI-specific information about the virtual this
 114   /// adjustment, if needed.
 115   union VirtualAdjustment {
 116     // Itanium ABI
 117     struct {
 118       /// The offset (in bytes), relative to the address point,
 119       /// of the virtual call offset.
 120       int64_t VCallOffsetOffset;
 121     } Itanium;
 122
 123     struct {
 124       /// The offset of the vtordisp (in bytes), relative to the ECX.
 125       int32_t VtordispOffset;
 126
 127       /// The offset of the vbptr of the derived class (in bytes),
 128       /// relative to the ECX after vtordisp adjustment.
 129       int32_t VBPtrOffset;
 130
 131       /// The offset (in bytes) of the vbase offset in the vbtable.
 132       int32_t VBOffsetOffset;
 133     } Microsoft;
 134
 135     VirtualAdjustment() {
 136       memset(this, 0, sizeof(*this));
 137     }
 138
 139     bool Equals(const VirtualAdjustment &Other) const {
 140       return memcmp(this, &Other, sizeof(Other)) == 0;
 141     }
 142
 143     bool isEmpty() const {
 144       VirtualAdjustment Zero;
 145       return Equals(Zero);
 146     }
 147
 148     bool Less(const VirtualAdjustment &RHS) const {
 149       return memcmp(this, &RHS, sizeof(RHS)) < 0;
 150     }
 151   } Virtual;
 152
 153   ThisAdjustment() : NonVirtual(0) { }
 154
 155   bool isEmpty() const { return !NonVirtual && Virtual.isEmpty(); }
 156
 157   friend bool operator==(const ThisAdjustment &LHS,
 158                          const ThisAdjustment &RHS) {
 159     return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Equals(RHS.Virtual);
 160   }
 161
 162   friend bool operator!=(const ThisAdjustment &LHS, const ThisAdjustment &RHS) {
 163     return !(LHS == RHS);
 164   }
 165
 166   friend bool operator<(const ThisAdjustment &LHS,
 167                         const ThisAdjustment &RHS) {
 168     if (LHS.NonVirtual < RHS.NonVirtual)
 169       return true;
 170
 171     return LHS.NonVirtual == RHS.NonVirtual && LHS.Virtual.Less(RHS.Virtual);
 172   }
 173 };
 174
 175 class CXXMethodDecl;
 176
 177 /// The \c this pointer adjustment as well as an optional return
 178 /// adjustment for a thunk.
 179 struct ThunkInfo {
 180   /// The \c this pointer adjustment.
 181   ThisAdjustment This;
 182
 183   /// The return adjustment.
 184   ReturnAdjustment Return;
 185
 186   /// Holds a pointer to the overridden method this thunk is for,
 187   /// if needed by the ABI to distinguish different thunks with equal
 188   /// adjustments. Otherwise, null.
 189   /// CAUTION: In the unlikely event you need to sort ThunkInfos, consider using
 190   /// an ABI-specific comparator.
 191   const CXXMethodDecl *Method;
 192
 193   ThunkInfo() : Method(nullptr) { }
 194
 195   ThunkInfo(const ThisAdjustment &This, const ReturnAdjustment &Return,
 196             const CXXMethodDecl *Method = nullptr)
 197       : This(This), Return(Return), Method(Method) {}
 198
 199   friend bool operator==(const ThunkInfo &LHS, const ThunkInfo &RHS) {
 200     return LHS.This == RHS.This && LHS.Return == RHS.Return &&
 201            LHS.Method == RHS.Method;
 202   }
 203
 204   bool isEmpty() const {
 205     return This.isEmpty() && Return.isEmpty() && Method == nullptr;
 206   }
 207 };
 208
 209 } // end namespace clang
 210
 211 #endif