add a generic "bitmangled pointer" class, which allows a parameterized

pointer and integer type to be used.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60224 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-11-28 23:31:44 +00:00
parent d3d12ecadd
commit 34b763694e

View File

@ -0,0 +1,69 @@
//===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the PointerIntPair class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_POINTERINTPAIR_H
#define LLVM_ADT_POINTERINTPAIR_H
#include <cassert>
namespace llvm {
/// PointerIntPair - This class implements a pair of a pointer and small
/// integer. It is designed to represet this in the space required by one
/// pointer by bitmangling the integer into the low part of the pointer. This
/// can only be done for small integers: typically up to 3 bits, but it depends
/// on the alignment returned by the allocator in use.
///
template <typename PointerTy, unsigned IntBits, typename IntType=unsigned>
class PointerIntPair {
intptr_t Value;
public:
PointerIntPair() : Value(0) {}
PointerIntPair(PointerTy Ptr, IntType Int) : Value(0) {
setPointer(Ptr);
setInt(Int);
}
PointerTy getPointer() const {
return reinterpret_cast<PointerTy>(Value & ~((1 << IntBits)-1));
}
IntType getInt() const {
return (IntType)(Value & (1 << IntBits)-1);
}
void setPointer(PointerTy Ptr) {
intptr_t PtrVal = reinterpret_cast<intptr_t>(Ptr);
assert((PtrVal & (1 << IntBits)-1) == 0 &&
"Pointer is no sufficiently aligned");
Value = PtrVal | (intptr_t)getInt();
}
void setInt(IntType Int) {
assert(Int < (1 << IntBits) && "Integer too large for field");
Value |= reinterpret_cast<intptr_t>(getPointer()) | (intptr_t)Int;
}
void *getOpaqueValue() const { return reinterpret_cast<void*>(Value); }
void setFromOpaqueValue(void *Val) { Value = reinterpret_cast<intptr_t>(Val);}
bool operator==(const PointerIntPair &RHS) const {
return Value == RHS.Value;
}
bool operator!=(const PointerIntPair &RHS) const {
return Value != RHS.Value;
}
};
} // end namespace llvm
#endif