Home | History | Annotate | Download | only in Basic 
      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 
     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.
     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 
     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.
     99 struct 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