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 /// \brief Enums/classes describing ABI related information about constructors, 12 /// destructors and thunks. 13 /// 14 //===----------------------------------------------------------------------===// 15 16 #ifndef CLANG_BASIC_ABI_H 17 #define CLANG_BASIC_ABI_H 18 19 #include "llvm/Support/DataTypes.h" 20 21 namespace clang { 22 23 /// \brief C++ constructor types. 24 enum CXXCtorType { 25 Ctor_Complete, ///< Complete object ctor 26 Ctor_Base, ///< Base object ctor 27 Ctor_CompleteAllocating ///< Complete object allocating ctor 28 }; 29 30 /// \brief C++ destructor types. 31 enum CXXDtorType { 32 Dtor_Deleting, ///< Deleting dtor 33 Dtor_Complete, ///< Complete object dtor 34 Dtor_Base ///< Base object dtor 35 }; 36 37 /// \brief A return adjustment. 38 struct ReturnAdjustment { 39 /// \brief The non-virtual adjustment from the derived object to its 40 /// nearest virtual base. 41 int64_t NonVirtual; 42 43 /// \brief The offset (in bytes), relative to the address point 44 /// of the virtual base class offset. 45 int64_t VBaseOffsetOffset; 46 ReturnAdjustmentReturnAdjustment47 ReturnAdjustment() : NonVirtual(0), VBaseOffsetOffset(0) { } 48 isEmptyReturnAdjustment49 bool isEmpty() const { return !NonVirtual && !VBaseOffsetOffset; } 50 51 friend bool operator==(const ReturnAdjustment &LHS, 52 const ReturnAdjustment &RHS) { 53 return LHS.NonVirtual == RHS.NonVirtual && 54 LHS.VBaseOffsetOffset == RHS.VBaseOffsetOffset; 55 } 56 57 friend bool operator<(const ReturnAdjustment &LHS, 58 const ReturnAdjustment &RHS) { 59 if (LHS.NonVirtual < RHS.NonVirtual) 60 return true; 61 62 return LHS.NonVirtual == RHS.NonVirtual && 63 LHS.VBaseOffsetOffset < RHS.VBaseOffsetOffset; 64 } 65 }; 66 67 /// \brief A \c this pointer adjustment. 68 struct ThisAdjustment { 69 /// \brief The non-virtual adjustment from the derived object to its 70 /// nearest virtual base. 71 int64_t NonVirtual; 72 73 /// \brief The offset (in bytes), relative to the address point, 74 /// of the virtual call offset. 75 int64_t VCallOffsetOffset; 76 ThisAdjustmentThisAdjustment77 ThisAdjustment() : NonVirtual(0), VCallOffsetOffset(0) { } 78 isEmptyThisAdjustment79 bool isEmpty() const { return !NonVirtual && !VCallOffsetOffset; } 80 81 friend bool operator==(const ThisAdjustment &LHS, 82 const ThisAdjustment &RHS) { 83 return LHS.NonVirtual == RHS.NonVirtual && 84 LHS.VCallOffsetOffset == RHS.VCallOffsetOffset; 85 } 86 87 friend bool operator<(const ThisAdjustment &LHS, 88 const ThisAdjustment &RHS) { 89 if (LHS.NonVirtual < RHS.NonVirtual) 90 return true; 91 92 return LHS.NonVirtual == RHS.NonVirtual && 93 LHS.VCallOffsetOffset < RHS.VCallOffsetOffset; 94 } 95 }; 96 97 /// \brief The \c this pointer adjustment as well as an optional return 98 /// adjustment for a thunk. 99 struct ThunkInfo { 100 /// \brief The \c this pointer adjustment. 101 ThisAdjustment This; 102 103 /// \brief The return adjustment. 104 ReturnAdjustment Return; 105 ThunkInfoThunkInfo106 ThunkInfo() { } 107 ThunkInfoThunkInfo108 ThunkInfo(const ThisAdjustment &This, const ReturnAdjustment &Return) 109 : This(This), Return(Return) { } 110 111 friend bool operator==(const ThunkInfo &LHS, const ThunkInfo &RHS) { 112 return LHS.This == RHS.This && LHS.Return == RHS.Return; 113 } 114 115 friend bool operator<(const ThunkInfo &LHS, const ThunkInfo &RHS) { 116 if (LHS.This < RHS.This) 117 return true; 118 119 return LHS.This == RHS.This && LHS.Return < RHS.Return; 120 } 121 isEmptyThunkInfo122 bool isEmpty() const { return This.isEmpty() && Return.isEmpty(); } 123 }; 124 125 } // end namespace clang 126 127 #endif // CLANG_BASIC_ABI_H 128