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