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 21namespace clang { 22 23/// \brief C++ constructor types. 24enum 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. 31enum 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. 38struct 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 47 ReturnAdjustment() : NonVirtual(0), VBaseOffsetOffset(0) { } 48 49 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. 68struct 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 77 ThisAdjustment() : NonVirtual(0), VCallOffsetOffset(0) { } 78 79 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. 99struct ThunkInfo { 100 /// \brief The \c this pointer adjustment. 101 ThisAdjustment This; 102 103 /// \brief The return adjustment. 104 ReturnAdjustment Return; 105 106 ThunkInfo() { } 107 108 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 122 bool isEmpty() const { return This.isEmpty() && Return.isEmpty(); } 123}; 124 125} // end namespace clang 126 127#endif // CLANG_BASIC_ABI_H 128