base_vptr.h

Go to the documentation of this file.

#ifndef VIRTMEM_BASE_VPTR_H
#define VIRTMEM_BASE_VPTR_H

#include "config/config.h"
#include "internal/alloc.h"
#include "utils.h"

#include <stddef.h>

namespace virtmem {

#ifndef VIRTMEM_CPP11
class NILL_t;
#else
typedef nullptr_t NILL_t;
#endif

namespace private_utils {

template <bool, typename T1, typename T2> struct Conditional
{
    typedef T1 type;
};

template <typename T1, typename T2> struct Conditional<false, T1, T2>
{
    typedef T2 type;
};

}

template <typename, typename> class VPtr;

class BaseVPtr
{
    struct Null { };

    // Safe bool idiom from boost::function
    struct Dummy { void nonNull(void) { } };
    typedef void (Dummy::*TSafeBool)(void);

    template <typename, typename> friend class VPtr;
    template <typename> friend class VPtrLock;

public:
#ifdef VIRTMEM_WRAP_CPOINTERS
#if defined(__x86_64__) || defined(_M_X64)
    typedef __uint128_t PtrNum;
#elif defined(__i386) || defined(_M_IX86)
    typedef uint64_t PtrNum;
#else
    typedef private_utils::Conditional<(sizeof(intptr_t) > sizeof(VPtrNum)), intptr_t, VPtrNum>::type PtrNum;
#endif
#else
    typedef VPtrNum PtrNum;
#endif

private:
#ifdef VIRTMEM_WRAP_CPOINTERS
    enum { WRAP_BIT = sizeof(PtrNum) * 8 - 1 }; // Last bit is used to check if wrapping real pointer
#endif

protected:
    // UNDONE
    // For debug
#if defined(VIRTMEM_WRAP_CPOINTERS) && (defined(__x86_64__) || defined(_M_X64))
    union
    {
        PtrNum ptr;
        struct
        {
            VPtrNum addr, wrapped;
        } ugh;
    };
#else
    PtrNum ptr; 
#endif

    // @cond HIDDEN_SYMBOLS
#ifdef VIRTMEM_WRAP_CPOINTERS
    // Return 'real' address of pointer, ie without wrapping bit
    // static so that ValueWrapper can use it as well
    static intptr_t getPtrNum(PtrNum p) { return p & ~((PtrNum)1 << WRAP_BIT); }
    static void *unwrap(PtrNum p) { ASSERT(isWrapped(p)); return reinterpret_cast<void *>(getPtrNum(p)); }
#else
    static intptr_t getPtrNum(PtrNum p) { return p; }
#endif
    intptr_t getPtrNum(void) const { return getPtrNum(ptr); } // Shortcut
    // @endcond

public:
#ifdef VIRTMEM_CPP11
    // Can only use these constructors on C++11, otherwise vptrs cannot be used with unions
    BaseVPtr(void) = default; // Must have this to remain union compatible
    BaseVPtr(NILL_t) : ptr(0) { } 
#endif

#ifdef VIRTMEM_WRAP_CPOINTERS

    static PtrNum getWrapped(PtrNum p) { return p | ((PtrNum)1 << WRAP_BIT); }
    static bool isWrapped(PtrNum p) { return p & ((PtrNum)1 << WRAP_BIT); }
    bool isWrapped(void) const { return isWrapped(ptr); }
#endif

    PtrNum getRawNum(void) const { return ptr; }
    void setRawNum(PtrNum p) { ptr = p; }

#ifdef VIRTMEM_WRAP_CPOINTERS

    static BaseVPtr wrap(const void *p)
    {
        BaseVPtr ret;
        ret.ptr = getWrapped(reinterpret_cast<PtrNum>(p));
        return ret;
    }
    void *unwrap(const BaseVPtr &p) { return unwrap(p); } 
    void *unwrap(void) { return unwrap(ptr); } 
    const void *unwrap(void) const { return unwrap(ptr); } 
#endif

    // HACK: this allows constructing VPtr objects from BaseVPtr variables, similar to
    // initializing non void pointers with a void pointer
    // Note that we could have used a copy constructor in VPtr instead, but this would make the latter
    // class non-POD
    template <typename T, typename A> VIRTMEM_EXPLICIT operator VPtr<T, A>(void) const { VPtr<T, A> ret; ret.ptr = ptr; return ret; }

    // allow checking with NULL
#ifndef VIRTMEM_CPP11
    inline bool operator==(const Null *) const { return getPtrNum() == 0; }
    friend inline bool operator==(const Null *, const BaseVPtr &pw) { return pw.getPtrNum() == 0; }
    inline bool operator!=(const Null *) const { return getPtrNum() != 0; }
    friend inline bool operator!=(const Null *, const BaseVPtr &pw) { return pw.getPtrNum() != 0; }
#endif
    inline bool operator==(const NILL_t &) const { return getPtrNum() == 0; }
    friend inline bool operator==(const NILL_t &, const BaseVPtr &pw) { return pw.getPtrNum() == 0; }
    inline bool operator!=(const NILL_t &) const { return getPtrNum() != 0; }
    friend inline bool operator!=(const NILL_t &, const BaseVPtr &pw) { return pw.getPtrNum() != 0; }
    inline operator TSafeBool (void) const { return getPtrNum() == 0 ? 0 : &Dummy::nonNull; }
    // @}

    // UNDONE: _int128_t comparison sometimes fails??? Perhaps only check for ptrnums/iswrapped when on x86-64? Test this!
#if (defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)) && defined(VIRTMEM_WRAP_CPOINTERS)
    inline bool operator==(const BaseVPtr &pb) const { return getPtrNum() == pb.getPtrNum() && isWrapped() == pb.isWrapped(); }
    inline bool operator!=(const BaseVPtr &pb) const { return getPtrNum() != pb.getPtrNum() && isWrapped() == pb.isWrapped(); }
    inline bool operator<(const BaseVPtr &pb) const { return getPtrNum() < pb.getPtrNum() && isWrapped() == pb.isWrapped(); }
    inline bool operator<=(const BaseVPtr &pb) const { return getPtrNum() <= pb.getPtrNum() && isWrapped() == pb.isWrapped(); }
    inline bool operator>=(const BaseVPtr &pb) const { return getPtrNum() >= pb.getPtrNum() && isWrapped() == pb.isWrapped(); }
    inline bool operator>(const BaseVPtr &pb) const { return getPtrNum() > pb.getPtrNum() && isWrapped() == pb.isWrapped(); }
    // @}
#else
    inline bool operator==(const BaseVPtr &pb) const { return ptr == pb.ptr; }
    inline bool operator!=(const BaseVPtr &pb) const { return ptr != pb.ptr; }
    inline bool operator<(const BaseVPtr &pb) const { return ptr < pb.ptr; }
    inline bool operator<=(const BaseVPtr &pb) const { return ptr <= pb.ptr; }
    inline bool operator>=(const BaseVPtr &pb) const { return ptr >= pb.ptr; }
    inline bool operator>(const BaseVPtr &pb) const { return ptr > pb.ptr; }
#endif

};

}


#endif // VIRTMEM_BASE_VPTR_H