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 18 void Constant::dumpOS(raw_ostream &OS) const { 19 dumpCommonPrefix(OS); 20 dumpCommonSuffix(OS); 21 } 22 #endif // NDEBUG 23 24 ConstantInt *ConstantInt::getTrue(Context &Ctx) { 25 auto *LLVMC = llvm::ConstantInt::getTrue(Ctx.LLVMCtx); 26 return cast<ConstantInt>(Ctx.getOrCreateConstant(LLVMC)); 27 } 28 ConstantInt *ConstantInt::getFalse(Context &Ctx) { 29 auto *LLVMC = llvm::ConstantInt::getFalse(Ctx.LLVMCtx); 30 return cast<ConstantInt>(Ctx.getOrCreateConstant(LLVMC)); 31 } 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 } 36 Constant *ConstantInt::getTrue(Type *Ty) { 37 auto *LLVMC = llvm::ConstantInt::getTrue(Ty->LLVMTy); 38 return Ty->getContext().getOrCreateConstant(LLVMC); 39 } 40 Constant *ConstantInt::getFalse(Type *Ty) { 41 auto *LLVMC = llvm::ConstantInt::getFalse(Ty->LLVMTy); 42 return Ty->getContext().getOrCreateConstant(LLVMC); 43 } 44 Constant *ConstantInt::getBool(Type *Ty, bool V) { 45 auto *LLVMC = llvm::ConstantInt::getBool(Ty->LLVMTy, V); 46 return Ty->getContext().getOrCreateConstant(LLVMC); 47 } 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 } 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 } 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 } 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 } 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 } 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 } 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 } 78 IntegerType *ConstantInt::getIntegerType() const { 79 auto *LLVMTy = cast<llvm::ConstantInt>(Val)->getIntegerType(); 80 return cast<IntegerType>(Ctx.getType(LLVMTy)); 81 } 82 83 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t V) { 84 return llvm::ConstantInt::isValueValidForType(Ty->LLVMTy, V); 85 } 86 bool ConstantInt::isValueValidForType(Type *Ty, int64_t V) { 87 return llvm::ConstantInt::isValueValidForType(Ty->LLVMTy, V); 88 } 89 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 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 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 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 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 } 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 } 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 } 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 } 126 Constant *ConstantFP::getNegativeZero(Type *Ty) { 127 auto *LLVMC = llvm::ConstantFP::getNegativeZero(Ty->LLVMTy); 128 return cast<Constant>(Ty->getContext().getOrCreateConstant(LLVMC)); 129 } 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 } 134 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat &V) { 135 return llvm::ConstantFP::isValueValidForType(Ty->LLVMTy, V); 136 } 137 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 149 ArrayType *ConstantArray::getType() const { 150 return cast<ArrayType>( 151 Ctx.getType(cast<llvm::ConstantArray>(Val)->getType())); 152 } 153 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 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 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 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 192 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 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 204 Constant *ConstantAggregateZero::getSequentialElement() const { 205 return cast<Constant>(Ctx.getValue( 206 cast<llvm::ConstantAggregateZero>(Val)->getSequentialElement())); 207 } 208 Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const { 209 return cast<Constant>(Ctx.getValue( 210 cast<llvm::ConstantAggregateZero>(Val)->getStructElement(Elt))); 211 } 212 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 } 217 Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const { 218 return cast<Constant>(Ctx.getValue( 219 cast<llvm::ConstantAggregateZero>(Val)->getElementValue(Idx))); 220 } 221 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 228 PointerType *ConstantPointerNull::getType() const { 229 return cast<PointerType>( 230 Ctx.getType(cast<llvm::ConstantPointerNull>(Val)->getType())); 231 } 232 233 UndefValue *UndefValue::get(Type *T) { 234 auto *LLVMC = llvm::UndefValue::get(T->LLVMTy); 235 return cast<UndefValue>(T->getContext().getOrCreateConstant(LLVMC)); 236 } 237 238 UndefValue *UndefValue::getSequentialElement() const { 239 return cast<UndefValue>(Ctx.getOrCreateConstant( 240 cast<llvm::UndefValue>(Val)->getSequentialElement())); 241 } 242 243 UndefValue *UndefValue::getStructElement(unsigned Elt) const { 244 return cast<UndefValue>(Ctx.getOrCreateConstant( 245 cast<llvm::UndefValue>(Val)->getStructElement(Elt))); 246 } 247 248 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 254 UndefValue *UndefValue::getElementValue(unsigned Idx) const { 255 return cast<UndefValue>(Ctx.getOrCreateConstant( 256 cast<llvm::UndefValue>(Val)->getElementValue(Idx))); 257 } 258 259 PoisonValue *PoisonValue::get(Type *T) { 260 auto *LLVMC = llvm::PoisonValue::get(T->LLVMTy); 261 return cast<PoisonValue>(T->getContext().getOrCreateConstant(LLVMC)); 262 } 263 264 PoisonValue *PoisonValue::getSequentialElement() const { 265 return cast<PoisonValue>(Ctx.getOrCreateConstant( 266 cast<llvm::PoisonValue>(Val)->getSequentialElement())); 267 } 268 269 PoisonValue *PoisonValue::getStructElement(unsigned Elt) const { 270 return cast<PoisonValue>(Ctx.getOrCreateConstant( 271 cast<llvm::PoisonValue>(Val)->getStructElement(Elt))); 272 } 273 274 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 280 PoisonValue *PoisonValue::getElementValue(unsigned Idx) const { 281 return cast<PoisonValue>(Ctx.getOrCreateConstant( 282 cast<llvm::PoisonValue>(Val)->getElementValue(Idx))); 283 } 284 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 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>:: 303 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 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 326 Constant *GlobalIFunc::getResolver() const { 327 return Ctx.getOrCreateConstant(cast<llvm::GlobalIFunc>(Val)->getResolver()); 328 } 329 330 Function *GlobalIFunc::getResolverFunction() { 331 return cast<Function>(Ctx.getOrCreateConstant( 332 cast<llvm::GlobalIFunc>(Val)->getResolverFunction())); 333 } 334 335 GlobalVariable & 336 GlobalVariable::LLVMGVToGV::operator()(llvm::GlobalVariable &LLVMGV) const { 337 return cast<GlobalVariable>(*Ctx.getValue(&LLVMGV)); 338 } 339 340 Constant *GlobalVariable::getInitializer() const { 341 return Ctx.getOrCreateConstant( 342 cast<llvm::GlobalVariable>(Val)->getInitializer()); 343 } 344 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 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 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 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 376 Constant *GlobalAlias::getAliasee() const { 377 return cast<Constant>( 378 Ctx.getOrCreateConstant(cast<llvm::GlobalAlias>(Val)->getAliasee())); 379 } 380 381 const GlobalObject *GlobalAlias::getAliaseeObject() const { 382 return cast<GlobalObject>(Ctx.getOrCreateConstant( 383 cast<llvm::GlobalAlias>(Val)->getAliaseeObject())); 384 } 385 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 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 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 405 GlobalValue *NoCFIValue::getGlobalValue() const { 406 auto *LLVMC = cast<llvm::NoCFIValue>(Val)->getGlobalValue(); 407 return cast<GlobalValue>(Ctx.getOrCreateConstant(LLVMC)); 408 } 409 410 PointerType *NoCFIValue::getType() const { 411 return cast<PointerType>(Ctx.getType(cast<llvm::NoCFIValue>(Val)->getType())); 412 } 413 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 422 Constant *ConstantPtrAuth::getPointer() const { 423 return Ctx.getOrCreateConstant( 424 cast<llvm::ConstantPtrAuth>(Val)->getPointer()); 425 } 426 427 ConstantInt *ConstantPtrAuth::getKey() const { 428 return cast<ConstantInt>( 429 Ctx.getOrCreateConstant(cast<llvm::ConstantPtrAuth>(Val)->getKey())); 430 } 431 432 ConstantInt *ConstantPtrAuth::getDiscriminator() const { 433 return cast<ConstantInt>(Ctx.getOrCreateConstant( 434 cast<llvm::ConstantPtrAuth>(Val)->getDiscriminator())); 435 } 436 437 Constant *ConstantPtrAuth::getAddrDiscriminator() const { 438 return Ctx.getOrCreateConstant( 439 cast<llvm::ConstantPtrAuth>(Val)->getAddrDiscriminator()); 440 } 441 442 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 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 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 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 464 Function *BlockAddress::getFunction() const { 465 return cast<Function>( 466 Ctx.getValue(cast<llvm::BlockAddress>(Val)->getFunction())); 467 } 468 469 BasicBlock *BlockAddress::getBasicBlock() const { 470 return cast<BasicBlock>( 471 Ctx.getValue(cast<llvm::BlockAddress>(Val)->getBasicBlock())); 472 } 473 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 479 GlobalValue *DSOLocalEquivalent::getGlobalValue() const { 480 return cast<GlobalValue>( 481 Ctx.getValue(cast<llvm::DSOLocalEquivalent>(Val)->getGlobalValue())); 482 } 483 484 } // namespace llvm::sandboxir 485