1 //===- Constant.cpp - The Constant classes of Sandbox IR ------------------===//
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 #include "llvm/SandboxIR/Constant.h"
10 #include "llvm/SandboxIR/BasicBlock.h"
11 #include "llvm/SandboxIR/Context.h"
12 #include "llvm/SandboxIR/Function.h"
13 #include "llvm/Support/Compiler.h"
14
15 namespace llvm::sandboxir {
16
17 #ifndef NDEBUG
dumpOS(raw_ostream & OS) const18 void Constant::dumpOS(raw_ostream &OS) const {
19 dumpCommonPrefix(OS);
20 dumpCommonSuffix(OS);
21 }
22 #endif // NDEBUG
23
getTrue(Context & Ctx)24 ConstantInt *ConstantInt::getTrue(Context &Ctx) {
25 auto *LLVMC = llvm::ConstantInt::getTrue(Ctx.LLVMCtx);
26 return cast<ConstantInt>(Ctx.getOrCreateConstant(LLVMC));
27 }
getFalse(Context & Ctx)28 ConstantInt *ConstantInt::getFalse(Context &Ctx) {
29 auto *LLVMC = llvm::ConstantInt::getFalse(Ctx.LLVMCtx);
30 return cast<ConstantInt>(Ctx.getOrCreateConstant(LLVMC));
31 }
getBool(Context & Ctx,bool V)32 ConstantInt *ConstantInt::getBool(Context &Ctx, bool V) {
33 auto *LLVMC = llvm::ConstantInt::getBool(Ctx.LLVMCtx, V);
34 return cast<ConstantInt>(Ctx.getOrCreateConstant(LLVMC));
35 }
getTrue(Type * Ty)36 Constant *ConstantInt::getTrue(Type *Ty) {
37 auto *LLVMC = llvm::ConstantInt::getTrue(Ty->LLVMTy);
38 return Ty->getContext().getOrCreateConstant(LLVMC);
39 }
getFalse(Type * Ty)40 Constant *ConstantInt::getFalse(Type *Ty) {
41 auto *LLVMC = llvm::ConstantInt::getFalse(Ty->LLVMTy);
42 return Ty->getContext().getOrCreateConstant(LLVMC);
43 }
getBool(Type * Ty,bool V)44 Constant *ConstantInt::getBool(Type *Ty, bool V) {
45 auto *LLVMC = llvm::ConstantInt::getBool(Ty->LLVMTy, V);
46 return Ty->getContext().getOrCreateConstant(LLVMC);
47 }
get(Type * Ty,uint64_t V,bool IsSigned)48 ConstantInt *ConstantInt::get(Type *Ty, uint64_t V, bool IsSigned) {
49 auto *LLVMC = llvm::ConstantInt::get(Ty->LLVMTy, V, IsSigned);
50 return cast<ConstantInt>(Ty->getContext().getOrCreateConstant(LLVMC));
51 }
get(IntegerType * Ty,uint64_t V,bool IsSigned)52 ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool IsSigned) {
53 auto *LLVMC = llvm::ConstantInt::get(Ty->LLVMTy, V, IsSigned);
54 return cast<ConstantInt>(Ty->getContext().getOrCreateConstant(LLVMC));
55 }
getSigned(IntegerType * Ty,int64_t V)56 ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) {
57 auto *LLVMC =
58 llvm::ConstantInt::getSigned(cast<llvm::IntegerType>(Ty->LLVMTy), V);
59 return cast<ConstantInt>(Ty->getContext().getOrCreateConstant(LLVMC));
60 }
getSigned(Type * Ty,int64_t V)61 Constant *ConstantInt::getSigned(Type *Ty, int64_t V) {
62 auto *LLVMC = llvm::ConstantInt::getSigned(Ty->LLVMTy, V);
63 return Ty->getContext().getOrCreateConstant(LLVMC);
64 }
get(Context & Ctx,const APInt & V)65 ConstantInt *ConstantInt::get(Context &Ctx, const APInt &V) {
66 auto *LLVMC = llvm::ConstantInt::get(Ctx.LLVMCtx, V);
67 return cast<ConstantInt>(Ctx.getOrCreateConstant(LLVMC));
68 }
get(IntegerType * Ty,StringRef Str,uint8_t Radix)69 ConstantInt *ConstantInt::get(IntegerType *Ty, StringRef Str, uint8_t Radix) {
70 auto *LLVMC =
71 llvm::ConstantInt::get(cast<llvm::IntegerType>(Ty->LLVMTy), Str, Radix);
72 return cast<ConstantInt>(Ty->getContext().getOrCreateConstant(LLVMC));
73 }
get(Type * Ty,const APInt & V)74 Constant *ConstantInt::get(Type *Ty, const APInt &V) {
75 auto *LLVMC = llvm::ConstantInt::get(Ty->LLVMTy, V);
76 return Ty->getContext().getOrCreateConstant(LLVMC);
77 }
getIntegerType() const78 IntegerType *ConstantInt::getIntegerType() const {
79 auto *LLVMTy = cast<llvm::ConstantInt>(Val)->getIntegerType();
80 return cast<IntegerType>(Ctx.getType(LLVMTy));
81 }
82
isValueValidForType(Type * Ty,uint64_t V)83 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t V) {
84 return llvm::ConstantInt::isValueValidForType(Ty->LLVMTy, V);
85 }
isValueValidForType(Type * Ty,int64_t V)86 bool ConstantInt::isValueValidForType(Type *Ty, int64_t V) {
87 return llvm::ConstantInt::isValueValidForType(Ty->LLVMTy, V);
88 }
89
get(Type * Ty,double V)90 Constant *ConstantFP::get(Type *Ty, double V) {
91 auto *LLVMC = llvm::ConstantFP::get(Ty->LLVMTy, V);
92 return Ty->getContext().getOrCreateConstant(LLVMC);
93 }
94
get(Type * Ty,const APFloat & V)95 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
96 auto *LLVMC = llvm::ConstantFP::get(Ty->LLVMTy, V);
97 return Ty->getContext().getOrCreateConstant(LLVMC);
98 }
99
get(Type * Ty,StringRef Str)100 Constant *ConstantFP::get(Type *Ty, StringRef Str) {
101 auto *LLVMC = llvm::ConstantFP::get(Ty->LLVMTy, Str);
102 return Ty->getContext().getOrCreateConstant(LLVMC);
103 }
104
get(const APFloat & V,Context & Ctx)105 ConstantFP *ConstantFP::get(const APFloat &V, Context &Ctx) {
106 auto *LLVMC = llvm::ConstantFP::get(Ctx.LLVMCtx, V);
107 return cast<ConstantFP>(Ctx.getOrCreateConstant(LLVMC));
108 }
109
getNaN(Type * Ty,bool Negative,uint64_t Payload)110 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
111 auto *LLVMC = llvm::ConstantFP::getNaN(Ty->LLVMTy, Negative, Payload);
112 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC));
113 }
getQNaN(Type * Ty,bool Negative,APInt * Payload)114 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
115 auto *LLVMC = llvm::ConstantFP::getQNaN(Ty->LLVMTy, Negative, Payload);
116 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC));
117 }
getSNaN(Type * Ty,bool Negative,APInt * Payload)118 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
119 auto *LLVMC = llvm::ConstantFP::getSNaN(Ty->LLVMTy, Negative, Payload);
120 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC));
121 }
getZero(Type * Ty,bool Negative)122 Constant *ConstantFP::getZero(Type *Ty, bool Negative) {
123 auto *LLVMC = llvm::ConstantFP::getZero(Ty->LLVMTy, Negative);
124 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC));
125 }
getNegativeZero(Type * Ty)126 Constant *ConstantFP::getNegativeZero(Type *Ty) {
127 auto *LLVMC = llvm::ConstantFP::getNegativeZero(Ty->LLVMTy);
128 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC));
129 }
getInfinity(Type * Ty,bool Negative)130 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
131 auto *LLVMC = llvm::ConstantFP::getInfinity(Ty->LLVMTy, Negative);
132 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC));
133 }
isValueValidForType(Type * Ty,const APFloat & V)134 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat &V) {
135 return llvm::ConstantFP::isValueValidForType(Ty->LLVMTy, V);
136 }
137
get(ArrayType * T,ArrayRef<Constant * > V)138 Constant *ConstantArray::get(ArrayType *T, ArrayRef<Constant *> V) {
139 auto &Ctx = T->getContext();
140 SmallVector<llvm::Constant *> LLVMValues;
141 LLVMValues.reserve(V.size());
142 for (auto *Elm : V)
143 LLVMValues.push_back(cast<llvm::Constant>(Elm->Val));
144 auto *LLVMC =
145 llvm::ConstantArray::get(cast<llvm::ArrayType>(T->LLVMTy), LLVMValues);
146 return cast<ConstantArray>(Ctx.getOrCreateConstant(LLVMC));
147 }
148
getType() const149 ArrayType *ConstantArray::getType() const {
150 return cast<ArrayType>(
151 Ctx.getType(cast<llvm::ConstantArray>(Val)->getType()));
152 }
153
get(StructType * T,ArrayRef<Constant * > V)154 Constant *ConstantStruct::get(StructType *T, ArrayRef<Constant *> V) {
155 auto &Ctx = T->getContext();
156 SmallVector<llvm::Constant *> LLVMValues;
157 LLVMValues.reserve(V.size());
158 for (auto *Elm : V)
159 LLVMValues.push_back(cast<llvm::Constant>(Elm->Val));
160 auto *LLVMC =
161 llvm::ConstantStruct::get(cast<llvm::StructType>(T->LLVMTy), LLVMValues);
162 return cast<ConstantStruct>(Ctx.getOrCreateConstant(LLVMC));
163 }
164
getTypeForElements(Context & Ctx,ArrayRef<Constant * > V,bool Packed)165 StructType *ConstantStruct::getTypeForElements(Context &Ctx,
166 ArrayRef<Constant *> V,
167 bool Packed) {
168 unsigned VecSize = V.size();
169 SmallVector<Type *, 16> EltTypes;
170 EltTypes.reserve(VecSize);
171 for (Constant *Elm : V)
172 EltTypes.push_back(Elm->getType());
173 return StructType::get(Ctx, EltTypes, Packed);
174 }
175
get(ArrayRef<Constant * > V)176 Constant *ConstantVector::get(ArrayRef<Constant *> V) {
177 assert(!V.empty() && "Expected non-empty V!");
178 auto &Ctx = V[0]->getContext();
179 SmallVector<llvm::Constant *, 8> LLVMV;
180 LLVMV.reserve(V.size());
181 for (auto *Elm : V)
182 LLVMV.push_back(cast<llvm::Constant>(Elm->Val));
183 return Ctx.getOrCreateConstant(llvm::ConstantVector::get(LLVMV));
184 }
185
getSplat(ElementCount EC,Constant * Elt)186 Constant *ConstantVector::getSplat(ElementCount EC, Constant *Elt) {
187 auto *LLVMElt = cast<llvm::Constant>(Elt->Val);
188 auto &Ctx = Elt->getContext();
189 return Ctx.getOrCreateConstant(llvm::ConstantVector::getSplat(EC, LLVMElt));
190 }
191
getSplatValue(bool AllowPoison) const192 Constant *ConstantVector::getSplatValue(bool AllowPoison) const {
193 auto *LLVMSplatValue = cast_or_null<llvm::Constant>(
194 cast<llvm::ConstantVector>(Val)->getSplatValue(AllowPoison));
195 return LLVMSplatValue ? Ctx.getOrCreateConstant(LLVMSplatValue) : nullptr;
196 }
197
get(Type * Ty)198 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
199 auto *LLVMC = llvm::ConstantAggregateZero::get(Ty->LLVMTy);
200 return cast<ConstantAggregateZero>(
201 Ty->getContext().getOrCreateConstant(LLVMC));
202 }
203
getSequentialElement() const204 Constant *ConstantAggregateZero::getSequentialElement() const {
205 return cast<Constant>(Ctx.getValue(
206 cast<llvm::ConstantAggregateZero>(Val)->getSequentialElement()));
207 }
getStructElement(unsigned Elt) const208 Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const {
209 return cast<Constant>(Ctx.getValue(
210 cast<llvm::ConstantAggregateZero>(Val)->getStructElement(Elt)));
211 }
getElementValue(Constant * C) const212 Constant *ConstantAggregateZero::getElementValue(Constant *C) const {
213 return cast<Constant>(
214 Ctx.getValue(cast<llvm::ConstantAggregateZero>(Val)->getElementValue(
215 cast<llvm::Constant>(C->Val))));
216 }
getElementValue(unsigned Idx) const217 Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const {
218 return cast<Constant>(Ctx.getValue(
219 cast<llvm::ConstantAggregateZero>(Val)->getElementValue(Idx)));
220 }
221
get(PointerType * Ty)222 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
223 auto *LLVMC =
224 llvm::ConstantPointerNull::get(cast<llvm::PointerType>(Ty->LLVMTy));
225 return cast<ConstantPointerNull>(Ty->getContext().getOrCreateConstant(LLVMC));
226 }
227
getType() const228 PointerType *ConstantPointerNull::getType() const {
229 return cast<PointerType>(
230 Ctx.getType(cast<llvm::ConstantPointerNull>(Val)->getType()));
231 }
232
get(Type * T)233 UndefValue *UndefValue::get(Type *T) {
234 auto *LLVMC = llvm::UndefValue::get(T->LLVMTy);
235 return cast<UndefValue>(T->getContext().getOrCreateConstant(LLVMC));
236 }
237
getSequentialElement() const238 UndefValue *UndefValue::getSequentialElement() const {
239 return cast<UndefValue>(Ctx.getOrCreateConstant(
240 cast<llvm::UndefValue>(Val)->getSequentialElement()));
241 }
242
getStructElement(unsigned Elt) const243 UndefValue *UndefValue::getStructElement(unsigned Elt) const {
244 return cast<UndefValue>(Ctx.getOrCreateConstant(
245 cast<llvm::UndefValue>(Val)->getStructElement(Elt)));
246 }
247
getElementValue(Constant * C) const248 UndefValue *UndefValue::getElementValue(Constant *C) const {
249 return cast<UndefValue>(
250 Ctx.getOrCreateConstant(cast<llvm::UndefValue>(Val)->getElementValue(
251 cast<llvm::Constant>(C->Val))));
252 }
253
getElementValue(unsigned Idx) const254 UndefValue *UndefValue::getElementValue(unsigned Idx) const {
255 return cast<UndefValue>(Ctx.getOrCreateConstant(
256 cast<llvm::UndefValue>(Val)->getElementValue(Idx)));
257 }
258
get(Type * T)259 PoisonValue *PoisonValue::get(Type *T) {
260 auto *LLVMC = llvm::PoisonValue::get(T->LLVMTy);
261 return cast<PoisonValue>(T->getContext().getOrCreateConstant(LLVMC));
262 }
263
getSequentialElement() const264 PoisonValue *PoisonValue::getSequentialElement() const {
265 return cast<PoisonValue>(Ctx.getOrCreateConstant(
266 cast<llvm::PoisonValue>(Val)->getSequentialElement()));
267 }
268
getStructElement(unsigned Elt) const269 PoisonValue *PoisonValue::getStructElement(unsigned Elt) const {
270 return cast<PoisonValue>(Ctx.getOrCreateConstant(
271 cast<llvm::PoisonValue>(Val)->getStructElement(Elt)));
272 }
273
getElementValue(Constant * C) const274 PoisonValue *PoisonValue::getElementValue(Constant *C) const {
275 return cast<PoisonValue>(
276 Ctx.getOrCreateConstant(cast<llvm::PoisonValue>(Val)->getElementValue(
277 cast<llvm::Constant>(C->Val))));
278 }
279
getElementValue(unsigned Idx) const280 PoisonValue *PoisonValue::getElementValue(unsigned Idx) const {
281 return cast<PoisonValue>(Ctx.getOrCreateConstant(
282 cast<llvm::PoisonValue>(Val)->getElementValue(Idx)));
283 }
284
setAlignment(MaybeAlign Align)285 void GlobalVariable::setAlignment(MaybeAlign Align) {
286 Ctx.getTracker()
287 .emplaceIfTracking<GenericSetter<&GlobalVariable::getAlign,
288 &GlobalVariable::setAlignment>>(this);
289 cast<llvm::GlobalVariable>(Val)->setAlignment(Align);
290 }
291
setSection(StringRef S)292 void GlobalObject::setSection(StringRef S) {
293 Ctx.getTracker()
294 .emplaceIfTracking<
295 GenericSetter<&GlobalObject::getSection, &GlobalObject::setSection>>(
296 this);
297 cast<llvm::GlobalObject>(Val)->setSection(S);
298 }
299
300 template <typename GlobalT, typename LLVMGlobalT, typename ParentT,
301 typename LLVMParentT>
302 GlobalT &GlobalWithNodeAPI<GlobalT, LLVMGlobalT, ParentT, LLVMParentT>::
operator ()(LLVMGlobalT & LLVMGV) const303 LLVMGVToGV::operator()(LLVMGlobalT &LLVMGV) const {
304 return cast<GlobalT>(*Ctx.getValue(&LLVMGV));
305 }
306
307 // Explicit instantiations.
308 template class LLVM_EXPORT_TEMPLATE GlobalWithNodeAPI<
309 GlobalIFunc, llvm::GlobalIFunc, GlobalObject, llvm::GlobalObject>;
310 template class LLVM_EXPORT_TEMPLATE GlobalWithNodeAPI<
311 Function, llvm::Function, GlobalObject, llvm::GlobalObject>;
312 template class LLVM_EXPORT_TEMPLATE GlobalWithNodeAPI<
313 GlobalVariable, llvm::GlobalVariable, GlobalObject, llvm::GlobalObject>;
314 template class LLVM_EXPORT_TEMPLATE GlobalWithNodeAPI<
315 GlobalAlias, llvm::GlobalAlias, GlobalValue, llvm::GlobalValue>;
316
setResolver(Constant * Resolver)317 void GlobalIFunc::setResolver(Constant *Resolver) {
318 Ctx.getTracker()
319 .emplaceIfTracking<
320 GenericSetter<&GlobalIFunc::getResolver, &GlobalIFunc::setResolver>>(
321 this);
322 cast<llvm::GlobalIFunc>(Val)->setResolver(
323 cast<llvm::Constant>(Resolver->Val));
324 }
325
getResolver() const326 Constant *GlobalIFunc::getResolver() const {
327 return Ctx.getOrCreateConstant(cast<llvm::GlobalIFunc>(Val)->getResolver());
328 }
329
getResolverFunction()330 Function *GlobalIFunc::getResolverFunction() {
331 return cast<Function>(Ctx.getOrCreateConstant(
332 cast<llvm::GlobalIFunc>(Val)->getResolverFunction()));
333 }
334
335 GlobalVariable &
operator ()(llvm::GlobalVariable & LLVMGV) const336 GlobalVariable::LLVMGVToGV::operator()(llvm::GlobalVariable &LLVMGV) const {
337 return cast<GlobalVariable>(*Ctx.getValue(&LLVMGV));
338 }
339
getInitializer() const340 Constant *GlobalVariable::getInitializer() const {
341 return Ctx.getOrCreateConstant(
342 cast<llvm::GlobalVariable>(Val)->getInitializer());
343 }
344
setInitializer(Constant * InitVal)345 void GlobalVariable::setInitializer(Constant *InitVal) {
346 Ctx.getTracker()
347 .emplaceIfTracking<GenericSetter<&GlobalVariable::getInitializer,
348 &GlobalVariable::setInitializer>>(this);
349 cast<llvm::GlobalVariable>(Val)->setInitializer(
350 cast<llvm::Constant>(InitVal->Val));
351 }
352
setConstant(bool V)353 void GlobalVariable::setConstant(bool V) {
354 Ctx.getTracker()
355 .emplaceIfTracking<GenericSetter<&GlobalVariable::isConstant,
356 &GlobalVariable::setConstant>>(this);
357 cast<llvm::GlobalVariable>(Val)->setConstant(V);
358 }
359
setExternallyInitialized(bool V)360 void GlobalVariable::setExternallyInitialized(bool V) {
361 Ctx.getTracker()
362 .emplaceIfTracking<
363 GenericSetter<&GlobalVariable::isExternallyInitialized,
364 &GlobalVariable::setExternallyInitialized>>(this);
365 cast<llvm::GlobalVariable>(Val)->setExternallyInitialized(V);
366 }
367
setAliasee(Constant * Aliasee)368 void GlobalAlias::setAliasee(Constant *Aliasee) {
369 Ctx.getTracker()
370 .emplaceIfTracking<
371 GenericSetter<&GlobalAlias::getAliasee, &GlobalAlias::setAliasee>>(
372 this);
373 cast<llvm::GlobalAlias>(Val)->setAliasee(cast<llvm::Constant>(Aliasee->Val));
374 }
375
getAliasee() const376 Constant *GlobalAlias::getAliasee() const {
377 return cast<Constant>(
378 Ctx.getOrCreateConstant(cast<llvm::GlobalAlias>(Val)->getAliasee()));
379 }
380
getAliaseeObject() const381 const GlobalObject *GlobalAlias::getAliaseeObject() const {
382 return cast<GlobalObject>(Ctx.getOrCreateConstant(
383 cast<llvm::GlobalAlias>(Val)->getAliaseeObject()));
384 }
385
setUnnamedAddr(UnnamedAddr V)386 void GlobalValue::setUnnamedAddr(UnnamedAddr V) {
387 Ctx.getTracker()
388 .emplaceIfTracking<GenericSetter<&GlobalValue::getUnnamedAddr,
389 &GlobalValue::setUnnamedAddr>>(this);
390 cast<llvm::GlobalValue>(Val)->setUnnamedAddr(V);
391 }
392
setVisibility(VisibilityTypes V)393 void GlobalValue::setVisibility(VisibilityTypes V) {
394 Ctx.getTracker()
395 .emplaceIfTracking<GenericSetter<&GlobalValue::getVisibility,
396 &GlobalValue::setVisibility>>(this);
397 cast<llvm::GlobalValue>(Val)->setVisibility(V);
398 }
399
get(GlobalValue * GV)400 NoCFIValue *NoCFIValue::get(GlobalValue *GV) {
401 auto *LLVMC = llvm::NoCFIValue::get(cast<llvm::GlobalValue>(GV->Val));
402 return cast<NoCFIValue>(GV->getContext().getOrCreateConstant(LLVMC));
403 }
404
getGlobalValue() const405 GlobalValue *NoCFIValue::getGlobalValue() const {
406 auto *LLVMC = cast<llvm::NoCFIValue>(Val)->getGlobalValue();
407 return cast<GlobalValue>(Ctx.getOrCreateConstant(LLVMC));
408 }
409
getType() const410 PointerType *NoCFIValue::getType() const {
411 return cast<PointerType>(Ctx.getType(cast<llvm::NoCFIValue>(Val)->getType()));
412 }
413
get(Constant * Ptr,ConstantInt * Key,ConstantInt * Disc,Constant * AddrDisc)414 ConstantPtrAuth *ConstantPtrAuth::get(Constant *Ptr, ConstantInt *Key,
415 ConstantInt *Disc, Constant *AddrDisc) {
416 auto *LLVMC = llvm::ConstantPtrAuth::get(
417 cast<llvm::Constant>(Ptr->Val), cast<llvm::ConstantInt>(Key->Val),
418 cast<llvm::ConstantInt>(Disc->Val), cast<llvm::Constant>(AddrDisc->Val));
419 return cast<ConstantPtrAuth>(Ptr->getContext().getOrCreateConstant(LLVMC));
420 }
421
getPointer() const422 Constant *ConstantPtrAuth::getPointer() const {
423 return Ctx.getOrCreateConstant(
424 cast<llvm::ConstantPtrAuth>(Val)->getPointer());
425 }
426
getKey() const427 ConstantInt *ConstantPtrAuth::getKey() const {
428 return cast<ConstantInt>(
429 Ctx.getOrCreateConstant(cast<llvm::ConstantPtrAuth>(Val)->getKey()));
430 }
431
getDiscriminator() const432 ConstantInt *ConstantPtrAuth::getDiscriminator() const {
433 return cast<ConstantInt>(Ctx.getOrCreateConstant(
434 cast<llvm::ConstantPtrAuth>(Val)->getDiscriminator()));
435 }
436
getAddrDiscriminator() const437 Constant *ConstantPtrAuth::getAddrDiscriminator() const {
438 return Ctx.getOrCreateConstant(
439 cast<llvm::ConstantPtrAuth>(Val)->getAddrDiscriminator());
440 }
441
getWithSameSchema(Constant * Pointer) const442 ConstantPtrAuth *ConstantPtrAuth::getWithSameSchema(Constant *Pointer) const {
443 auto *LLVMC = cast<llvm::ConstantPtrAuth>(Val)->getWithSameSchema(
444 cast<llvm::Constant>(Pointer->Val));
445 return cast<ConstantPtrAuth>(Ctx.getOrCreateConstant(LLVMC));
446 }
447
get(Function * F,BasicBlock * BB)448 BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
449 auto *LLVMC = llvm::BlockAddress::get(cast<llvm::Function>(F->Val),
450 cast<llvm::BasicBlock>(BB->Val));
451 return cast<BlockAddress>(F->getContext().getOrCreateConstant(LLVMC));
452 }
453
get(BasicBlock * BB)454 BlockAddress *BlockAddress::get(BasicBlock *BB) {
455 auto *LLVMC = llvm::BlockAddress::get(cast<llvm::BasicBlock>(BB->Val));
456 return cast<BlockAddress>(BB->getContext().getOrCreateConstant(LLVMC));
457 }
458
lookup(const BasicBlock * BB)459 BlockAddress *BlockAddress::lookup(const BasicBlock *BB) {
460 auto *LLVMC = llvm::BlockAddress::lookup(cast<llvm::BasicBlock>(BB->Val));
461 return cast_or_null<BlockAddress>(BB->getContext().getValue(LLVMC));
462 }
463
getFunction() const464 Function *BlockAddress::getFunction() const {
465 return cast<Function>(
466 Ctx.getValue(cast<llvm::BlockAddress>(Val)->getFunction()));
467 }
468
getBasicBlock() const469 BasicBlock *BlockAddress::getBasicBlock() const {
470 return cast<BasicBlock>(
471 Ctx.getValue(cast<llvm::BlockAddress>(Val)->getBasicBlock()));
472 }
473
get(GlobalValue * GV)474 DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalValue *GV) {
475 auto *LLVMC = llvm::DSOLocalEquivalent::get(cast<llvm::GlobalValue>(GV->Val));
476 return cast<DSOLocalEquivalent>(GV->getContext().getValue(LLVMC));
477 }
478
getGlobalValue() const479 GlobalValue *DSOLocalEquivalent::getGlobalValue() const {
480 return cast<GlobalValue>(
481 Ctx.getValue(cast<llvm::DSOLocalEquivalent>(Val)->getGlobalValue()));
482 }
483
484 } // namespace llvm::sandboxir
485