| 1 |
//===-- Address.h - An aligned address -------------------------*- C++ -*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This class provides a simple wrapper for a pair of a pointer and an |
| 10 |
// alignment. |
| 11 |
// |
| 12 |
//===----------------------------------------------------------------------===// |
| 13 |
|
| 14 |
#ifndef LLVM_CLANG_LIB_CODEGEN_ADDRESS_H |
| 15 |
#define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H |
| 16 |
|
| 17 |
#include "clang/AST/CharUnits.h" |
| 18 |
#include "llvm/ADT/PointerIntPair.h" |
| 19 |
#include "llvm/IR/Constants.h" |
| 20 |
#include "llvm/Support/MathExtras.h" |
| 21 |
|
| 22 |
namespace clang { |
| 23 |
namespace CodeGen { |
| 24 |
|
| 25 |
// We try to save some space by using 6 bits over two PointerIntPairs to store |
| 26 |
// the alignment. However, some arches don't support 3 bits in a PointerIntPair |
| 27 |
// so we fallback to storing the alignment separately. |
| 28 |
template <typename T, bool = alignof(llvm::Value *) >= 8> class AddressImpl {}; |
| 29 |
|
| 30 |
template <typename T> class AddressImpl<T, false> { |
| 31 |
llvm::Value *Pointer; |
| 32 |
llvm::Type *ElementType; |
| 33 |
CharUnits Alignment; |
| 34 |
|
| 35 |
public: |
| 36 |
AddressImpl(llvm::Value *Pointer, llvm::Type *ElementType, |
| 37 |
CharUnits Alignment) |
| 38 |
: Pointer(Pointer), ElementType(ElementType), Alignment(Alignment) {} |
| 39 |
llvm::Value *getPointer() const { return Pointer; } |
| 40 |
llvm::Type *getElementType() const { return ElementType; } |
| 41 |
CharUnits getAlignment() const { return Alignment; } |
| 42 |
}; |
| 43 |
|
| 44 |
template <typename T> class AddressImpl<T, true> { |
| 45 |
// Int portion stores upper 3 bits of the log of the alignment. |
| 46 |
llvm::PointerIntPair<llvm::Value *, 3, unsigned> Pointer; |
| 47 |
// Int portion stores lower 3 bits of the log of the alignment. |
| 48 |
llvm::PointerIntPair<llvm::Type *, 3, unsigned> ElementType; |
| 49 |
|
| 50 |
public: |
| 51 |
AddressImpl(llvm::Value *Pointer, llvm::Type *ElementType, |
| 52 |
CharUnits Alignment) |
| 53 |
: Pointer(Pointer), ElementType(ElementType) { |
| 54 |
if (Alignment.isZero()) |
| 55 |
return; |
| 56 |
// Currently the max supported alignment is much less than 1 << 63 and is |
| 57 |
// guaranteed to be a power of 2, so we can store the log of the alignment |
| 58 |
// into 6 bits. |
| 59 |
assert(Alignment.isPowerOfTwo() && "Alignment cannot be zero"); |
| 60 |
auto AlignLog = llvm::Log2_64(Alignment.getQuantity()); |
| 61 |
assert(AlignLog < (1 << 6) && "cannot fit alignment into 6 bits"); |
| 62 |
this->Pointer.setInt(AlignLog >> 3); |
| 63 |
this->ElementType.setInt(AlignLog & 7); |
| 64 |
} |
| 65 |
llvm::Value *getPointer() const { return Pointer.getPointer(); } |
| 66 |
llvm::Type *getElementType() const { return ElementType.getPointer(); } |
| 67 |
CharUnits getAlignment() const { |
| 68 |
unsigned AlignLog = (Pointer.getInt() << 3) | ElementType.getInt(); |
| 69 |
return CharUnits::fromQuantity(CharUnits::QuantityType(1) << AlignLog); |
| 70 |
} |
| 71 |
}; |
| 72 |
|
| 73 |
/// An aligned address. |
| 74 |
class Address { |
| 75 |
AddressImpl<void> A; |
| 76 |
|
| 77 |
protected: |
| 78 |
Address(std::nullptr_t) : A(nullptr, nullptr, CharUnits::Zero()) {} |
| 79 |
|
| 80 |
public: |
| 81 |
Address(llvm::Value *Pointer, llvm::Type *ElementType, CharUnits Alignment) |
| 82 |
: A(Pointer, ElementType, Alignment) { |
| 83 |
assert(Pointer != nullptr && "Pointer cannot be null"); |
| 84 |
assert(ElementType != nullptr && "Element type cannot be null"); |
| 85 |
assert(llvm::cast<llvm::PointerType>(Pointer->getType()) |
| 86 |
->isOpaqueOrPointeeTypeMatches(ElementType) && |
| 87 |
"Incorrect pointer element type"); |
| 88 |
} |
| 89 |
|
| 90 |
static Address invalid() { return Address(nullptr); } |
| 91 |
bool isValid() const { return A.getPointer() != nullptr; } |
| 92 |
|
| 93 |
llvm::Value *getPointer() const { |
| 94 |
assert(isValid()); |
| 95 |
return A.getPointer(); |
| 96 |
} |
| 97 |
|
| 98 |
/// Return the type of the pointer value. |
| 99 |
llvm::PointerType *getType() const { |
| 100 |
return llvm::cast<llvm::PointerType>(getPointer()->getType()); |
| 101 |
} |
| 102 |
|
| 103 |
/// Return the type of the values stored in this address. |
| 104 |
llvm::Type *getElementType() const { |
| 105 |
assert(isValid()); |
| 106 |
return A.getElementType(); |
| 107 |
} |
| 108 |
|
| 109 |
/// Return the address space that this address resides in. |
| 110 |
unsigned getAddressSpace() const { |
| 111 |
return getType()->getAddressSpace(); |
| 112 |
} |
| 113 |
|
| 114 |
/// Return the IR name of the pointer value. |
| 115 |
llvm::StringRef getName() const { |
| 116 |
return getPointer()->getName(); |
| 117 |
} |
| 118 |
|
| 119 |
/// Return the alignment of this pointer. |
| 120 |
CharUnits getAlignment() const { |
| 121 |
assert(isValid()); |
| 122 |
return A.getAlignment(); |
| 123 |
} |
| 124 |
|
| 125 |
/// Return address with different pointer, but same element type and |
| 126 |
/// alignment. |
| 127 |
Address withPointer(llvm::Value *NewPointer) const { |
| 128 |
return Address(NewPointer, getElementType(), getAlignment()); |
| 129 |
} |
| 130 |
|
| 131 |
/// Return address with different alignment, but same pointer and element |
| 132 |
/// type. |
| 133 |
Address withAlignment(CharUnits NewAlignment) const { |
| 134 |
return Address(getPointer(), getElementType(), NewAlignment); |
| 135 |
} |
| 136 |
}; |
| 137 |
|
| 138 |
/// A specialization of Address that requires the address to be an |
| 139 |
/// LLVM Constant. |
| 140 |
class ConstantAddress : public Address { |
| 141 |
ConstantAddress(std::nullptr_t) : Address(nullptr) {} |
| 142 |
|
| 143 |
public: |
| 144 |
ConstantAddress(llvm::Constant *pointer, llvm::Type *elementType, |
| 145 |
CharUnits alignment) |
| 146 |
: Address(pointer, elementType, alignment) {} |
| 147 |
|
| 148 |
static ConstantAddress invalid() { |
| 149 |
return ConstantAddress(nullptr); |
| 150 |
} |
| 151 |
|
| 152 |
llvm::Constant *getPointer() const { |
| 153 |
return llvm::cast<llvm::Constant>(Address::getPointer()); |
| 154 |
} |
| 155 |
|
| 156 |
ConstantAddress getElementBitCast(llvm::Type *ElemTy) const { |
| 157 |
llvm::Constant *BitCast = llvm::ConstantExpr::getBitCast( |
| 158 |
getPointer(), ElemTy->getPointerTo(getAddressSpace())); |
| 159 |
return ConstantAddress(BitCast, ElemTy, getAlignment()); |
| 160 |
} |
| 161 |
|
| 162 |
static bool isaImpl(Address addr) { |
| 163 |
return llvm::isa<llvm::Constant>(addr.getPointer()); |
| 164 |
} |
| 165 |
static ConstantAddress castImpl(Address addr) { |
| 166 |
return ConstantAddress(llvm::cast<llvm::Constant>(addr.getPointer()), |
| 167 |
addr.getElementType(), addr.getAlignment()); |
| 168 |
} |
| 169 |
}; |
| 170 |
|
| 171 |
} |
| 172 |
|
| 173 |
// Present a minimal LLVM-like casting interface. |
| 174 |
template <class U> inline U cast(CodeGen::Address addr) { |
| 175 |
return U::castImpl(addr); |
| 176 |
} |
| 177 |
template <class U> inline bool isa(CodeGen::Address addr) { |
| 178 |
return U::isaImpl(addr); |
| 179 |
} |
| 180 |
|
| 181 |
} |
| 182 |
|
| 183 |
#endif |