Debian Codegraph @

llvm-project/clang/lib/CodeGen/Address.h

raw
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