xref: /llvm-project/llvm/lib/SandboxIR/Instruction.cpp (revision 749443a307e8e47a25a5552cbeb27f69845e6ce8) 
1 //===- Instruction.cpp - The Instructions 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/Instruction.h"
10 #include "llvm/SandboxIR/Function.h"
11 
12 namespace llvm::sandboxir {
13 
14 const char *Instruction::getOpcodeName(Opcode Opc) {
15   switch (Opc) {
16 #define OP(OPC)                                                                \
17   case Opcode::OPC:                                                            \
18     return #OPC;
19 #define OPCODES(...) __VA_ARGS__
20 #define DEF_INSTR(ID, OPC, CLASS) OPC
21 #include "llvm/SandboxIR/Values.def"
22   }
23   llvm_unreachable("Unknown Opcode");
24 }
25 
26 llvm::Instruction *Instruction::getTopmostLLVMInstruction() const {
27   Instruction *Prev = getPrevNode();
28   if (Prev == nullptr) {
29     // If at top of the BB, return the first BB instruction.
30     return &*cast<llvm::BasicBlock>(getParent()->Val)->begin();
31   }
32   // Else get the Previous sandbox IR instruction's bottom IR instruction and
33   // return its successor.
34   llvm::Instruction *PrevBotI = cast<llvm::Instruction>(Prev->Val);
35   return PrevBotI->getNextNode();
36 }
37 
38 BBIterator Instruction::getIterator() const {
39   auto *I = cast<llvm::Instruction>(Val);
40   return BasicBlock::iterator(I->getParent(), I->getIterator(), &Ctx);
41 }
42 
43 Instruction *Instruction::getNextNode() const {
44   assert(getParent() != nullptr && "Detached!");
45   assert(getIterator() != getParent()->end() && "Already at end!");
46   // `Val` is the bottom-most LLVM IR instruction. Get the next in the chain,
47   // and get the corresponding sandboxir Instruction that maps to it. This works
48   // even for SandboxIR Instructions that map to more than one LLVM Instruction.
49   auto *LLVMI = cast<llvm::Instruction>(Val);
50   assert(LLVMI->getParent() != nullptr && "LLVM IR instr is detached!");
51   auto *NextLLVMI = LLVMI->getNextNode();
52   auto *NextI = cast_or_null<Instruction>(Ctx.getValue(NextLLVMI));
53   if (NextI == nullptr)
54     return nullptr;
55   return NextI;
56 }
57 
58 Instruction *Instruction::getPrevNode() const {
59   assert(getParent() != nullptr && "Detached!");
60   auto It = getIterator();
61   if (It != getParent()->begin())
62     return std::prev(getIterator()).get();
63   return nullptr;
64 }
65 
66 void Instruction::removeFromParent() {
67   Ctx.getTracker().emplaceIfTracking<RemoveFromParent>(this);
68 
69   // Detach all the LLVM IR instructions from their parent BB.
70   for (llvm::Instruction *I : getLLVMInstrs())
71     I->removeFromParent();
72 }
73 
74 void Instruction::eraseFromParent() {
75   assert(users().empty() && "Still connected to users, can't erase!");
76 
77   Ctx.runEraseInstrCallbacks(this);
78   std::unique_ptr<Value> Detached = Ctx.detach(this);
79   auto LLVMInstrs = getLLVMInstrs();
80 
81   auto &Tracker = Ctx.getTracker();
82   if (Tracker.isTracking()) {
83     Tracker.track(std::make_unique<EraseFromParent>(std::move(Detached)));
84     // We don't actually delete the IR instruction, because then it would be
85     // impossible to bring it back from the dead at the same memory location.
86     // Instead we remove it from its BB and track its current location.
87     for (llvm::Instruction *I : LLVMInstrs)
88       I->removeFromParent();
89     // TODO: Multi-instructions need special treatment because some of the
90     // references are internal to the instruction.
91     for (llvm::Instruction *I : LLVMInstrs)
92       I->dropAllReferences();
93   } else {
94     // Erase in reverse to avoid erasing nstructions with attached uses.
95     for (llvm::Instruction *I : reverse(LLVMInstrs))
96       I->eraseFromParent();
97   }
98 }
99 
100 void Instruction::moveBefore(BasicBlock &BB, const BBIterator &WhereIt) {
101   if (std::next(getIterator()) == WhereIt)
102     // Destination is same as origin, nothing to do.
103     return;
104 
105   Ctx.runMoveInstrCallbacks(this, WhereIt);
106   Ctx.getTracker().emplaceIfTracking<MoveInstr>(this);
107 
108   auto *LLVMBB = cast<llvm::BasicBlock>(BB.Val);
109   llvm::BasicBlock::iterator It;
110   if (WhereIt == BB.end()) {
111     It = LLVMBB->end();
112   } else {
113     Instruction *WhereI = &*WhereIt;
114     It = WhereI->getTopmostLLVMInstruction()->getIterator();
115   }
116   // TODO: Move this to the verifier of sandboxir::Instruction.
117   assert(is_sorted(getLLVMInstrs(),
118                    [](auto *I1, auto *I2) { return I1->comesBefore(I2); }) &&
119          "Expected program order!");
120   // Do the actual move in LLVM IR.
121   for (auto *I : getLLVMInstrs())
122     I->moveBefore(*LLVMBB, It);
123 }
124 
125 void Instruction::insertBefore(Instruction *BeforeI) {
126   llvm::Instruction *BeforeTopI = BeforeI->getTopmostLLVMInstruction();
127 
128   Ctx.getTracker().emplaceIfTracking<InsertIntoBB>(this);
129 
130   // Insert the LLVM IR Instructions in program order.
131   for (llvm::Instruction *I : getLLVMInstrs())
132     I->insertBefore(BeforeTopI->getIterator());
133 }
134 
135 void Instruction::insertAfter(Instruction *AfterI) {
136   insertInto(AfterI->getParent(), std::next(AfterI->getIterator()));
137 }
138 
139 void Instruction::insertInto(BasicBlock *BB, const BBIterator &WhereIt) {
140   llvm::BasicBlock *LLVMBB = cast<llvm::BasicBlock>(BB->Val);
141   llvm::Instruction *LLVMBeforeI;
142   llvm::BasicBlock::iterator LLVMBeforeIt;
143   Instruction *BeforeI;
144   if (WhereIt != BB->end()) {
145     BeforeI = &*WhereIt;
146     LLVMBeforeI = BeforeI->getTopmostLLVMInstruction();
147     LLVMBeforeIt = LLVMBeforeI->getIterator();
148   } else {
149     BeforeI = nullptr;
150     LLVMBeforeI = nullptr;
151     LLVMBeforeIt = LLVMBB->end();
152   }
153 
154   Ctx.getTracker().emplaceIfTracking<InsertIntoBB>(this);
155 
156   // Insert the LLVM IR Instructions in program order.
157   for (llvm::Instruction *I : getLLVMInstrs())
158     I->insertInto(LLVMBB, LLVMBeforeIt);
159 }
160 
161 BasicBlock *Instruction::getParent() const {
162   // Get the LLVM IR Instruction that this maps to, get its parent, and get the
163   // corresponding sandboxir::BasicBlock by looking it up in sandboxir::Context.
164   auto *BB = cast<llvm::Instruction>(Val)->getParent();
165   if (BB == nullptr)
166     return nullptr;
167   return cast<BasicBlock>(Ctx.getValue(BB));
168 }
169 
170 bool Instruction::classof(const sandboxir::Value *From) {
171   switch (From->getSubclassID()) {
172 #define DEF_INSTR(ID, OPC, CLASS)                                              \
173   case ClassID::ID:                                                            \
174     return true;
175 #include "llvm/SandboxIR/Values.def"
176   default:
177     return false;
178   }
179 }
180 
181 void Instruction::setHasNoUnsignedWrap(bool B) {
182   Ctx.getTracker()
183       .emplaceIfTracking<GenericSetter<&Instruction::hasNoUnsignedWrap,
184                                        &Instruction::setHasNoUnsignedWrap>>(
185           this);
186   cast<llvm::Instruction>(Val)->setHasNoUnsignedWrap(B);
187 }
188 
189 void Instruction::setHasNoSignedWrap(bool B) {
190   Ctx.getTracker()
191       .emplaceIfTracking<GenericSetter<&Instruction::hasNoSignedWrap,
192                                        &Instruction::setHasNoSignedWrap>>(this);
193   cast<llvm::Instruction>(Val)->setHasNoSignedWrap(B);
194 }
195 
196 void Instruction::setFast(bool B) {
197   Ctx.getTracker()
198       .emplaceIfTracking<
199           GenericSetter<&Instruction::isFast, &Instruction::setFast>>(this);
200   cast<llvm::Instruction>(Val)->setFast(B);
201 }
202 
203 void Instruction::setIsExact(bool B) {
204   Ctx.getTracker()
205       .emplaceIfTracking<
206           GenericSetter<&Instruction::isExact, &Instruction::setIsExact>>(this);
207   cast<llvm::Instruction>(Val)->setIsExact(B);
208 }
209 
210 void Instruction::setHasAllowReassoc(bool B) {
211   Ctx.getTracker()
212       .emplaceIfTracking<GenericSetter<&Instruction::hasAllowReassoc,
213                                        &Instruction::setHasAllowReassoc>>(this);
214   cast<llvm::Instruction>(Val)->setHasAllowReassoc(B);
215 }
216 
217 void Instruction::setHasNoNaNs(bool B) {
218   Ctx.getTracker()
219       .emplaceIfTracking<
220           GenericSetter<&Instruction::hasNoNaNs, &Instruction::setHasNoNaNs>>(
221           this);
222   cast<llvm::Instruction>(Val)->setHasNoNaNs(B);
223 }
224 
225 void Instruction::setHasNoInfs(bool B) {
226   Ctx.getTracker()
227       .emplaceIfTracking<
228           GenericSetter<&Instruction::hasNoInfs, &Instruction::setHasNoInfs>>(
229           this);
230   cast<llvm::Instruction>(Val)->setHasNoInfs(B);
231 }
232 
233 void Instruction::setHasNoSignedZeros(bool B) {
234   Ctx.getTracker()
235       .emplaceIfTracking<GenericSetter<&Instruction::hasNoSignedZeros,
236                                        &Instruction::setHasNoSignedZeros>>(
237           this);
238   cast<llvm::Instruction>(Val)->setHasNoSignedZeros(B);
239 }
240 
241 void Instruction::setHasAllowReciprocal(bool B) {
242   Ctx.getTracker()
243       .emplaceIfTracking<GenericSetter<&Instruction::hasAllowReciprocal,
244                                        &Instruction::setHasAllowReciprocal>>(
245           this);
246   cast<llvm::Instruction>(Val)->setHasAllowReciprocal(B);
247 }
248 
249 void Instruction::setHasAllowContract(bool B) {
250   Ctx.getTracker()
251       .emplaceIfTracking<GenericSetter<&Instruction::hasAllowContract,
252                                        &Instruction::setHasAllowContract>>(
253           this);
254   cast<llvm::Instruction>(Val)->setHasAllowContract(B);
255 }
256 
257 void Instruction::setFastMathFlags(FastMathFlags FMF) {
258   Ctx.getTracker()
259       .emplaceIfTracking<GenericSetter<&Instruction::getFastMathFlags,
260                                        &Instruction::copyFastMathFlags>>(this);
261   cast<llvm::Instruction>(Val)->setFastMathFlags(FMF);
262 }
263 
264 void Instruction::copyFastMathFlags(FastMathFlags FMF) {
265   Ctx.getTracker()
266       .emplaceIfTracking<GenericSetter<&Instruction::getFastMathFlags,
267                                        &Instruction::copyFastMathFlags>>(this);
268   cast<llvm::Instruction>(Val)->copyFastMathFlags(FMF);
269 }
270 
271 Type *Instruction::getAccessType() const {
272   return Ctx.getType(cast<llvm::Instruction>(Val)->getAccessType());
273 }
274 
275 void Instruction::setHasApproxFunc(bool B) {
276   Ctx.getTracker()
277       .emplaceIfTracking<GenericSetter<&Instruction::hasApproxFunc,
278                                        &Instruction::setHasApproxFunc>>(this);
279   cast<llvm::Instruction>(Val)->setHasApproxFunc(B);
280 }
281 
282 #ifndef NDEBUG
283 void Instruction::dumpOS(raw_ostream &OS) const {
284   OS << "Unimplemented! Please override dump().";
285 }
286 #endif // NDEBUG
287 
288 VAArgInst *VAArgInst::create(Value *List, Type *Ty, InsertPosition Pos,
289                              Context &Ctx, const Twine &Name) {
290   auto &Builder = setInsertPos(Pos);
291   auto *LLVMI =
292       cast<llvm::VAArgInst>(Builder.CreateVAArg(List->Val, Ty->LLVMTy, Name));
293   return Ctx.createVAArgInst(LLVMI);
294 }
295 
296 Value *VAArgInst::getPointerOperand() {
297   return Ctx.getValue(cast<llvm::VAArgInst>(Val)->getPointerOperand());
298 }
299 
300 FreezeInst *FreezeInst::create(Value *V, InsertPosition Pos, Context &Ctx,
301                                const Twine &Name) {
302   auto &Builder = setInsertPos(Pos);
303   auto *LLVMI = cast<llvm::FreezeInst>(Builder.CreateFreeze(V->Val, Name));
304   return Ctx.createFreezeInst(LLVMI);
305 }
306 
307 FenceInst *FenceInst::create(AtomicOrdering Ordering, InsertPosition Pos,
308                              Context &Ctx, SyncScope::ID SSID) {
309   auto &Builder = Instruction::setInsertPos(Pos);
310   llvm::FenceInst *LLVMI = Builder.CreateFence(Ordering, SSID);
311   return Ctx.createFenceInst(LLVMI);
312 }
313 
314 void FenceInst::setOrdering(AtomicOrdering Ordering) {
315   Ctx.getTracker()
316       .emplaceIfTracking<
317           GenericSetter<&FenceInst::getOrdering, &FenceInst::setOrdering>>(
318           this);
319   cast<llvm::FenceInst>(Val)->setOrdering(Ordering);
320 }
321 
322 void FenceInst::setSyncScopeID(SyncScope::ID SSID) {
323   Ctx.getTracker()
324       .emplaceIfTracking<GenericSetter<&FenceInst::getSyncScopeID,
325                                        &FenceInst::setSyncScopeID>>(this);
326   cast<llvm::FenceInst>(Val)->setSyncScopeID(SSID);
327 }
328 
329 Value *SelectInst::create(Value *Cond, Value *True, Value *False,
330                           InsertPosition Pos, Context &Ctx, const Twine &Name) {
331   auto &Builder = Instruction::setInsertPos(Pos);
332   llvm::Value *NewV =
333       Builder.CreateSelect(Cond->Val, True->Val, False->Val, Name);
334   if (auto *NewSI = dyn_cast<llvm::SelectInst>(NewV))
335     return Ctx.createSelectInst(NewSI);
336   assert(isa<llvm::Constant>(NewV) && "Expected constant");
337   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
338 }
339 
340 void SelectInst::swapValues() {
341   Ctx.getTracker().emplaceIfTracking<UseSwap>(getOperandUse(1),
342                                               getOperandUse(2));
343   cast<llvm::SelectInst>(Val)->swapValues();
344 }
345 
346 bool SelectInst::classof(const Value *From) {
347   return From->getSubclassID() == ClassID::Select;
348 }
349 
350 BranchInst *BranchInst::create(BasicBlock *IfTrue, InsertPosition Pos,
351                                Context &Ctx) {
352   auto &Builder = setInsertPos(Pos);
353   llvm::BranchInst *NewBr =
354       Builder.CreateBr(cast<llvm::BasicBlock>(IfTrue->Val));
355   return Ctx.createBranchInst(NewBr);
356 }
357 
358 BranchInst *BranchInst::create(BasicBlock *IfTrue, BasicBlock *IfFalse,
359                                Value *Cond, InsertPosition Pos, Context &Ctx) {
360   auto &Builder = setInsertPos(Pos);
361   llvm::BranchInst *NewBr =
362       Builder.CreateCondBr(Cond->Val, cast<llvm::BasicBlock>(IfTrue->Val),
363                            cast<llvm::BasicBlock>(IfFalse->Val));
364   return Ctx.createBranchInst(NewBr);
365 }
366 
367 bool BranchInst::classof(const Value *From) {
368   return From->getSubclassID() == ClassID::Br;
369 }
370 
371 Value *BranchInst::getCondition() const {
372   assert(isConditional() && "Cannot get condition of an uncond branch!");
373   return Ctx.getValue(cast<llvm::BranchInst>(Val)->getCondition());
374 }
375 
376 BasicBlock *BranchInst::getSuccessor(unsigned SuccIdx) const {
377   assert(SuccIdx < getNumSuccessors() &&
378          "Successor # out of range for Branch!");
379   return cast_or_null<BasicBlock>(
380       Ctx.getValue(cast<llvm::BranchInst>(Val)->getSuccessor(SuccIdx)));
381 }
382 
383 void BranchInst::setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
384   assert((Idx == 0 || Idx == 1) && "Out of bounds!");
385   setOperand(2u - Idx, NewSucc);
386 }
387 
388 BasicBlock *BranchInst::LLVMBBToSBBB::operator()(llvm::BasicBlock *BB) const {
389   return cast<BasicBlock>(Ctx.getValue(BB));
390 }
391 const BasicBlock *
392 BranchInst::ConstLLVMBBToSBBB::operator()(const llvm::BasicBlock *BB) const {
393   return cast<BasicBlock>(Ctx.getValue(BB));
394 }
395 
396 void LoadInst::setVolatile(bool V) {
397   Ctx.getTracker()
398       .emplaceIfTracking<
399           GenericSetter<&LoadInst::isVolatile, &LoadInst::setVolatile>>(this);
400   cast<llvm::LoadInst>(Val)->setVolatile(V);
401 }
402 
403 LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align,
404                            InsertPosition Pos, bool IsVolatile, Context &Ctx,
405                            const Twine &Name) {
406   auto &Builder = setInsertPos(Pos);
407   auto *NewLI =
408       Builder.CreateAlignedLoad(Ty->LLVMTy, Ptr->Val, Align, IsVolatile, Name);
409   auto *NewSBI = Ctx.createLoadInst(NewLI);
410   return NewSBI;
411 }
412 
413 bool LoadInst::classof(const Value *From) {
414   return From->getSubclassID() == ClassID::Load;
415 }
416 
417 Value *LoadInst::getPointerOperand() const {
418   return Ctx.getValue(cast<llvm::LoadInst>(Val)->getPointerOperand());
419 }
420 
421 void StoreInst::setVolatile(bool V) {
422   Ctx.getTracker()
423       .emplaceIfTracking<
424           GenericSetter<&StoreInst::isVolatile, &StoreInst::setVolatile>>(this);
425   cast<llvm::StoreInst>(Val)->setVolatile(V);
426 }
427 
428 StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align,
429                              InsertPosition Pos, bool IsVolatile,
430                              Context &Ctx) {
431   auto &Builder = setInsertPos(Pos);
432   auto *NewSI = Builder.CreateAlignedStore(V->Val, Ptr->Val, Align, IsVolatile);
433   auto *NewSBI = Ctx.createStoreInst(NewSI);
434   return NewSBI;
435 }
436 
437 bool StoreInst::classof(const Value *From) {
438   return From->getSubclassID() == ClassID::Store;
439 }
440 
441 Value *StoreInst::getValueOperand() const {
442   return Ctx.getValue(cast<llvm::StoreInst>(Val)->getValueOperand());
443 }
444 
445 Value *StoreInst::getPointerOperand() const {
446   return Ctx.getValue(cast<llvm::StoreInst>(Val)->getPointerOperand());
447 }
448 
449 UnreachableInst *UnreachableInst::create(InsertPosition Pos, Context &Ctx) {
450   auto &Builder = setInsertPos(Pos);
451   llvm::UnreachableInst *NewUI = Builder.CreateUnreachable();
452   return Ctx.createUnreachableInst(NewUI);
453 }
454 
455 bool UnreachableInst::classof(const Value *From) {
456   return From->getSubclassID() == ClassID::Unreachable;
457 }
458 
459 ReturnInst *ReturnInst::createCommon(Value *RetVal, IRBuilder<> &Builder,
460                                      Context &Ctx) {
461   llvm::ReturnInst *NewRI;
462   if (RetVal != nullptr)
463     NewRI = Builder.CreateRet(RetVal->Val);
464   else
465     NewRI = Builder.CreateRetVoid();
466   return Ctx.createReturnInst(NewRI);
467 }
468 
469 ReturnInst *ReturnInst::create(Value *RetVal, InsertPosition Pos,
470                                Context &Ctx) {
471   auto &Builder = setInsertPos(Pos);
472   return createCommon(RetVal, Builder, Ctx);
473 }
474 
475 Value *ReturnInst::getReturnValue() const {
476   auto *LLVMRetVal = cast<llvm::ReturnInst>(Val)->getReturnValue();
477   return LLVMRetVal != nullptr ? Ctx.getValue(LLVMRetVal) : nullptr;
478 }
479 
480 FunctionType *CallBase::getFunctionType() const {
481   return cast<FunctionType>(
482       Ctx.getType(cast<llvm::CallBase>(Val)->getFunctionType()));
483 }
484 
485 Value *CallBase::getCalledOperand() const {
486   return Ctx.getValue(cast<llvm::CallBase>(Val)->getCalledOperand());
487 }
488 
489 Use CallBase::getCalledOperandUse() const {
490   llvm::Use *LLVMUse = &cast<llvm::CallBase>(Val)->getCalledOperandUse();
491   return Use(LLVMUse, cast<User>(Ctx.getValue(LLVMUse->getUser())), Ctx);
492 }
493 
494 Function *CallBase::getCalledFunction() const {
495   return cast_or_null<Function>(
496       Ctx.getValue(cast<llvm::CallBase>(Val)->getCalledFunction()));
497 }
498 Function *CallBase::getCaller() {
499   return cast<Function>(Ctx.getValue(cast<llvm::CallBase>(Val)->getCaller()));
500 }
501 
502 void CallBase::setCalledFunction(Function *F) {
503   // F's function type is private, so we rely on `setCalledFunction()` to update
504   // it. But even though we are calling `setCalledFunction()` we also need to
505   // track this change at the SandboxIR level, which is why we call
506   // `setCalledOperand()` here.
507   // Note: This may break if `setCalledFunction()` early returns if `F`
508   // is already set, but we do have a unit test for it.
509   setCalledOperand(F);
510   cast<llvm::CallBase>(Val)->setCalledFunction(
511       cast<llvm::FunctionType>(F->getFunctionType()->LLVMTy),
512       cast<llvm::Function>(F->Val));
513 }
514 
515 CallInst *CallInst::create(FunctionType *FTy, Value *Func,
516                            ArrayRef<Value *> Args, InsertPosition Pos,
517                            Context &Ctx, const Twine &NameStr) {
518   auto &Builder = setInsertPos(Pos);
519   SmallVector<llvm::Value *> LLVMArgs;
520   LLVMArgs.reserve(Args.size());
521   for (Value *Arg : Args)
522     LLVMArgs.push_back(Arg->Val);
523   llvm::CallInst *NewCI = Builder.CreateCall(
524       cast<llvm::FunctionType>(FTy->LLVMTy), Func->Val, LLVMArgs, NameStr);
525   return Ctx.createCallInst(NewCI);
526 }
527 
528 InvokeInst *InvokeInst::create(FunctionType *FTy, Value *Func,
529                                BasicBlock *IfNormal, BasicBlock *IfException,
530                                ArrayRef<Value *> Args, InsertPosition Pos,
531                                Context &Ctx, const Twine &NameStr) {
532   auto &Builder = setInsertPos(Pos);
533   SmallVector<llvm::Value *> LLVMArgs;
534   LLVMArgs.reserve(Args.size());
535   for (Value *Arg : Args)
536     LLVMArgs.push_back(Arg->Val);
537   llvm::InvokeInst *Invoke = Builder.CreateInvoke(
538       cast<llvm::FunctionType>(FTy->LLVMTy), Func->Val,
539       cast<llvm::BasicBlock>(IfNormal->Val),
540       cast<llvm::BasicBlock>(IfException->Val), LLVMArgs, NameStr);
541   return Ctx.createInvokeInst(Invoke);
542 }
543 
544 BasicBlock *InvokeInst::getNormalDest() const {
545   return cast<BasicBlock>(
546       Ctx.getValue(cast<llvm::InvokeInst>(Val)->getNormalDest()));
547 }
548 BasicBlock *InvokeInst::getUnwindDest() const {
549   return cast<BasicBlock>(
550       Ctx.getValue(cast<llvm::InvokeInst>(Val)->getUnwindDest()));
551 }
552 void InvokeInst::setNormalDest(BasicBlock *BB) {
553   setOperand(1, BB);
554   assert(getNormalDest() == BB && "LLVM IR uses a different operan index!");
555 }
556 void InvokeInst::setUnwindDest(BasicBlock *BB) {
557   setOperand(2, BB);
558   assert(getUnwindDest() == BB && "LLVM IR uses a different operan index!");
559 }
560 LandingPadInst *InvokeInst::getLandingPadInst() const {
561   return cast<LandingPadInst>(
562       Ctx.getValue(cast<llvm::InvokeInst>(Val)->getLandingPadInst()));
563   ;
564 }
565 BasicBlock *InvokeInst::getSuccessor(unsigned SuccIdx) const {
566   return cast<BasicBlock>(
567       Ctx.getValue(cast<llvm::InvokeInst>(Val)->getSuccessor(SuccIdx)));
568 }
569 
570 CallBrInst *CallBrInst::create(FunctionType *FTy, Value *Func,
571                                BasicBlock *DefaultDest,
572                                ArrayRef<BasicBlock *> IndirectDests,
573                                ArrayRef<Value *> Args, InsertPosition Pos,
574                                Context &Ctx, const Twine &NameStr) {
575   auto &Builder = setInsertPos(Pos);
576   SmallVector<llvm::BasicBlock *> LLVMIndirectDests;
577   LLVMIndirectDests.reserve(IndirectDests.size());
578   for (BasicBlock *IndDest : IndirectDests)
579     LLVMIndirectDests.push_back(cast<llvm::BasicBlock>(IndDest->Val));
580 
581   SmallVector<llvm::Value *> LLVMArgs;
582   LLVMArgs.reserve(Args.size());
583   for (Value *Arg : Args)
584     LLVMArgs.push_back(Arg->Val);
585 
586   llvm::CallBrInst *CallBr =
587       Builder.CreateCallBr(cast<llvm::FunctionType>(FTy->LLVMTy), Func->Val,
588                            cast<llvm::BasicBlock>(DefaultDest->Val),
589                            LLVMIndirectDests, LLVMArgs, NameStr);
590   return Ctx.createCallBrInst(CallBr);
591 }
592 
593 Value *CallBrInst::getIndirectDestLabel(unsigned Idx) const {
594   return Ctx.getValue(cast<llvm::CallBrInst>(Val)->getIndirectDestLabel(Idx));
595 }
596 Value *CallBrInst::getIndirectDestLabelUse(unsigned Idx) const {
597   return Ctx.getValue(
598       cast<llvm::CallBrInst>(Val)->getIndirectDestLabelUse(Idx));
599 }
600 BasicBlock *CallBrInst::getDefaultDest() const {
601   return cast<BasicBlock>(
602       Ctx.getValue(cast<llvm::CallBrInst>(Val)->getDefaultDest()));
603 }
604 BasicBlock *CallBrInst::getIndirectDest(unsigned Idx) const {
605   return cast<BasicBlock>(
606       Ctx.getValue(cast<llvm::CallBrInst>(Val)->getIndirectDest(Idx)));
607 }
608 llvm::SmallVector<BasicBlock *, 16> CallBrInst::getIndirectDests() const {
609   SmallVector<BasicBlock *, 16> BBs;
610   for (llvm::BasicBlock *LLVMBB :
611        cast<llvm::CallBrInst>(Val)->getIndirectDests())
612     BBs.push_back(cast<BasicBlock>(Ctx.getValue(LLVMBB)));
613   return BBs;
614 }
615 void CallBrInst::setDefaultDest(BasicBlock *BB) {
616   Ctx.getTracker()
617       .emplaceIfTracking<GenericSetter<&CallBrInst::getDefaultDest,
618                                        &CallBrInst::setDefaultDest>>(this);
619   cast<llvm::CallBrInst>(Val)->setDefaultDest(cast<llvm::BasicBlock>(BB->Val));
620 }
621 void CallBrInst::setIndirectDest(unsigned Idx, BasicBlock *BB) {
622   Ctx.getTracker()
623       .emplaceIfTracking<GenericSetterWithIdx<&CallBrInst::getIndirectDest,
624                                               &CallBrInst::setIndirectDest>>(
625           this, Idx);
626   cast<llvm::CallBrInst>(Val)->setIndirectDest(Idx,
627                                                cast<llvm::BasicBlock>(BB->Val));
628 }
629 BasicBlock *CallBrInst::getSuccessor(unsigned Idx) const {
630   return cast<BasicBlock>(
631       Ctx.getValue(cast<llvm::CallBrInst>(Val)->getSuccessor(Idx)));
632 }
633 
634 LandingPadInst *LandingPadInst::create(Type *RetTy, unsigned NumReservedClauses,
635                                        InsertPosition Pos, Context &Ctx,
636                                        const Twine &Name) {
637   auto &Builder = setInsertPos(Pos);
638   llvm::LandingPadInst *LLVMI =
639       Builder.CreateLandingPad(RetTy->LLVMTy, NumReservedClauses, Name);
640   return Ctx.createLandingPadInst(LLVMI);
641 }
642 
643 void LandingPadInst::setCleanup(bool V) {
644   Ctx.getTracker()
645       .emplaceIfTracking<GenericSetter<&LandingPadInst::isCleanup,
646                                        &LandingPadInst::setCleanup>>(this);
647   cast<llvm::LandingPadInst>(Val)->setCleanup(V);
648 }
649 
650 Constant *LandingPadInst::getClause(unsigned Idx) const {
651   return cast<Constant>(
652       Ctx.getValue(cast<llvm::LandingPadInst>(Val)->getClause(Idx)));
653 }
654 
655 Value *FuncletPadInst::getParentPad() const {
656   return Ctx.getValue(cast<llvm::FuncletPadInst>(Val)->getParentPad());
657 }
658 
659 void FuncletPadInst::setParentPad(Value *ParentPad) {
660   Ctx.getTracker()
661       .emplaceIfTracking<GenericSetter<&FuncletPadInst::getParentPad,
662                                        &FuncletPadInst::setParentPad>>(this);
663   cast<llvm::FuncletPadInst>(Val)->setParentPad(ParentPad->Val);
664 }
665 
666 Value *FuncletPadInst::getArgOperand(unsigned Idx) const {
667   return Ctx.getValue(cast<llvm::FuncletPadInst>(Val)->getArgOperand(Idx));
668 }
669 
670 void FuncletPadInst::setArgOperand(unsigned Idx, Value *V) {
671   Ctx.getTracker()
672       .emplaceIfTracking<GenericSetterWithIdx<&FuncletPadInst::getArgOperand,
673                                               &FuncletPadInst::setArgOperand>>(
674           this, Idx);
675   cast<llvm::FuncletPadInst>(Val)->setArgOperand(Idx, V->Val);
676 }
677 
678 CatchSwitchInst *CatchPadInst::getCatchSwitch() const {
679   return cast<CatchSwitchInst>(
680       Ctx.getValue(cast<llvm::CatchPadInst>(Val)->getCatchSwitch()));
681 }
682 
683 CatchPadInst *CatchPadInst::create(Value *ParentPad, ArrayRef<Value *> Args,
684                                    InsertPosition Pos, Context &Ctx,
685                                    const Twine &Name) {
686   auto &Builder = setInsertPos(Pos);
687   SmallVector<llvm::Value *> LLVMArgs;
688   LLVMArgs.reserve(Args.size());
689   for (auto *Arg : Args)
690     LLVMArgs.push_back(Arg->Val);
691   llvm::CatchPadInst *LLVMI =
692       Builder.CreateCatchPad(ParentPad->Val, LLVMArgs, Name);
693   return Ctx.createCatchPadInst(LLVMI);
694 }
695 
696 CleanupPadInst *CleanupPadInst::create(Value *ParentPad, ArrayRef<Value *> Args,
697                                        InsertPosition Pos, Context &Ctx,
698                                        const Twine &Name) {
699   auto &Builder = setInsertPos(Pos);
700   SmallVector<llvm::Value *> LLVMArgs;
701   LLVMArgs.reserve(Args.size());
702   for (auto *Arg : Args)
703     LLVMArgs.push_back(Arg->Val);
704   llvm::CleanupPadInst *LLVMI =
705       Builder.CreateCleanupPad(ParentPad->Val, LLVMArgs, Name);
706   return Ctx.createCleanupPadInst(LLVMI);
707 }
708 
709 CatchReturnInst *CatchReturnInst::create(CatchPadInst *CatchPad, BasicBlock *BB,
710                                          InsertPosition Pos, Context &Ctx) {
711   auto &Builder = setInsertPos(Pos);
712   llvm::CatchReturnInst *LLVMI = Builder.CreateCatchRet(
713       cast<llvm::CatchPadInst>(CatchPad->Val), cast<llvm::BasicBlock>(BB->Val));
714   return Ctx.createCatchReturnInst(LLVMI);
715 }
716 
717 CatchPadInst *CatchReturnInst::getCatchPad() const {
718   return cast<CatchPadInst>(
719       Ctx.getValue(cast<llvm::CatchReturnInst>(Val)->getCatchPad()));
720 }
721 
722 void CatchReturnInst::setCatchPad(CatchPadInst *CatchPad) {
723   Ctx.getTracker()
724       .emplaceIfTracking<GenericSetter<&CatchReturnInst::getCatchPad,
725                                        &CatchReturnInst::setCatchPad>>(this);
726   cast<llvm::CatchReturnInst>(Val)->setCatchPad(
727       cast<llvm::CatchPadInst>(CatchPad->Val));
728 }
729 
730 BasicBlock *CatchReturnInst::getSuccessor() const {
731   return cast<BasicBlock>(
732       Ctx.getValue(cast<llvm::CatchReturnInst>(Val)->getSuccessor()));
733 }
734 
735 void CatchReturnInst::setSuccessor(BasicBlock *NewSucc) {
736   Ctx.getTracker()
737       .emplaceIfTracking<GenericSetter<&CatchReturnInst::getSuccessor,
738                                        &CatchReturnInst::setSuccessor>>(this);
739   cast<llvm::CatchReturnInst>(Val)->setSuccessor(
740       cast<llvm::BasicBlock>(NewSucc->Val));
741 }
742 
743 Value *CatchReturnInst::getCatchSwitchParentPad() const {
744   return Ctx.getValue(
745       cast<llvm::CatchReturnInst>(Val)->getCatchSwitchParentPad());
746 }
747 
748 CleanupReturnInst *CleanupReturnInst::create(CleanupPadInst *CleanupPad,
749                                              BasicBlock *UnwindBB,
750                                              InsertPosition Pos, Context &Ctx) {
751   auto &Builder = setInsertPos(Pos);
752   auto *LLVMUnwindBB =
753       UnwindBB != nullptr ? cast<llvm::BasicBlock>(UnwindBB->Val) : nullptr;
754   llvm::CleanupReturnInst *LLVMI = Builder.CreateCleanupRet(
755       cast<llvm::CleanupPadInst>(CleanupPad->Val), LLVMUnwindBB);
756   return Ctx.createCleanupReturnInst(LLVMI);
757 }
758 
759 CleanupPadInst *CleanupReturnInst::getCleanupPad() const {
760   return cast<CleanupPadInst>(
761       Ctx.getValue(cast<llvm::CleanupReturnInst>(Val)->getCleanupPad()));
762 }
763 
764 void CleanupReturnInst::setCleanupPad(CleanupPadInst *CleanupPad) {
765   Ctx.getTracker()
766       .emplaceIfTracking<GenericSetter<&CleanupReturnInst::getCleanupPad,
767                                        &CleanupReturnInst::setCleanupPad>>(
768           this);
769   cast<llvm::CleanupReturnInst>(Val)->setCleanupPad(
770       cast<llvm::CleanupPadInst>(CleanupPad->Val));
771 }
772 
773 BasicBlock *CleanupReturnInst::getUnwindDest() const {
774   return cast_or_null<BasicBlock>(
775       Ctx.getValue(cast<llvm::CleanupReturnInst>(Val)->getUnwindDest()));
776 }
777 
778 void CleanupReturnInst::setUnwindDest(BasicBlock *NewDest) {
779   Ctx.getTracker()
780       .emplaceIfTracking<GenericSetter<&CleanupReturnInst::getUnwindDest,
781                                        &CleanupReturnInst::setUnwindDest>>(
782           this);
783   cast<llvm::CleanupReturnInst>(Val)->setUnwindDest(
784       cast<llvm::BasicBlock>(NewDest->Val));
785 }
786 
787 Value *GetElementPtrInst::create(Type *Ty, Value *Ptr,
788                                  ArrayRef<Value *> IdxList, InsertPosition Pos,
789                                  Context &Ctx, const Twine &NameStr) {
790   auto &Builder = setInsertPos(Pos);
791   SmallVector<llvm::Value *> LLVMIdxList;
792   LLVMIdxList.reserve(IdxList.size());
793   for (Value *Idx : IdxList)
794     LLVMIdxList.push_back(Idx->Val);
795   llvm::Value *NewV =
796       Builder.CreateGEP(Ty->LLVMTy, Ptr->Val, LLVMIdxList, NameStr);
797   if (auto *NewGEP = dyn_cast<llvm::GetElementPtrInst>(NewV))
798     return Ctx.createGetElementPtrInst(NewGEP);
799   assert(isa<llvm::Constant>(NewV) && "Expected constant");
800   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
801 }
802 
803 Type *GetElementPtrInst::getSourceElementType() const {
804   return Ctx.getType(
805       cast<llvm::GetElementPtrInst>(Val)->getSourceElementType());
806 }
807 
808 Type *GetElementPtrInst::getResultElementType() const {
809   return Ctx.getType(
810       cast<llvm::GetElementPtrInst>(Val)->getResultElementType());
811 }
812 
813 Value *GetElementPtrInst::getPointerOperand() const {
814   return Ctx.getValue(cast<llvm::GetElementPtrInst>(Val)->getPointerOperand());
815 }
816 
817 Type *GetElementPtrInst::getPointerOperandType() const {
818   return Ctx.getType(
819       cast<llvm::GetElementPtrInst>(Val)->getPointerOperandType());
820 }
821 
822 BasicBlock *PHINode::LLVMBBToBB::operator()(llvm::BasicBlock *LLVMBB) const {
823   return cast<BasicBlock>(Ctx.getValue(LLVMBB));
824 }
825 
826 PHINode *PHINode::create(Type *Ty, unsigned NumReservedValues,
827                          InsertPosition Pos, Context &Ctx, const Twine &Name) {
828   auto &Builder = setInsertPos(Pos);
829   llvm::PHINode *NewPHI =
830       Builder.CreatePHI(Ty->LLVMTy, NumReservedValues, Name);
831   return Ctx.createPHINode(NewPHI);
832 }
833 
834 bool PHINode::classof(const Value *From) {
835   return From->getSubclassID() == ClassID::PHI;
836 }
837 
838 Value *PHINode::getIncomingValue(unsigned Idx) const {
839   return Ctx.getValue(cast<llvm::PHINode>(Val)->getIncomingValue(Idx));
840 }
841 void PHINode::setIncomingValue(unsigned Idx, Value *V) {
842   Ctx.getTracker()
843       .emplaceIfTracking<GenericSetterWithIdx<&PHINode::getIncomingValue,
844                                               &PHINode::setIncomingValue>>(this,
845                                                                            Idx);
846   cast<llvm::PHINode>(Val)->setIncomingValue(Idx, V->Val);
847 }
848 BasicBlock *PHINode::getIncomingBlock(unsigned Idx) const {
849   return cast<BasicBlock>(
850       Ctx.getValue(cast<llvm::PHINode>(Val)->getIncomingBlock(Idx)));
851 }
852 BasicBlock *PHINode::getIncomingBlock(const Use &U) const {
853   llvm::Use *LLVMUse = U.LLVMUse;
854   llvm::BasicBlock *BB = cast<llvm::PHINode>(Val)->getIncomingBlock(*LLVMUse);
855   return cast<BasicBlock>(Ctx.getValue(BB));
856 }
857 void PHINode::setIncomingBlock(unsigned Idx, BasicBlock *BB) {
858   // Helper to disambiguate PHINode::getIncomingBlock(unsigned).
859   constexpr BasicBlock *(PHINode::*GetIncomingBlockFn)(unsigned) const =
860       &PHINode::getIncomingBlock;
861   Ctx.getTracker()
862       .emplaceIfTracking<
863           GenericSetterWithIdx<GetIncomingBlockFn, &PHINode::setIncomingBlock>>(
864           this, Idx);
865   cast<llvm::PHINode>(Val)->setIncomingBlock(Idx,
866                                              cast<llvm::BasicBlock>(BB->Val));
867 }
868 void PHINode::addIncoming(Value *V, BasicBlock *BB) {
869   auto &Tracker = Ctx.getTracker();
870   Tracker.emplaceIfTracking<PHIAddIncoming>(this);
871 
872   cast<llvm::PHINode>(Val)->addIncoming(V->Val,
873                                         cast<llvm::BasicBlock>(BB->Val));
874 }
875 Value *PHINode::removeIncomingValue(unsigned Idx) {
876   auto &Tracker = Ctx.getTracker();
877   Tracker.emplaceIfTracking<PHIRemoveIncoming>(this, Idx);
878   llvm::Value *LLVMV =
879       cast<llvm::PHINode>(Val)->removeIncomingValue(Idx,
880                                                     /*DeletePHIIfEmpty=*/false);
881   return Ctx.getValue(LLVMV);
882 }
883 Value *PHINode::removeIncomingValue(BasicBlock *BB) {
884   auto &Tracker = Ctx.getTracker();
885   Tracker.emplaceIfTracking<PHIRemoveIncoming>(this, getBasicBlockIndex(BB));
886 
887   auto *LLVMBB = cast<llvm::BasicBlock>(BB->Val);
888   llvm::Value *LLVMV =
889       cast<llvm::PHINode>(Val)->removeIncomingValue(LLVMBB,
890                                                     /*DeletePHIIfEmpty=*/false);
891   return Ctx.getValue(LLVMV);
892 }
893 int PHINode::getBasicBlockIndex(const BasicBlock *BB) const {
894   auto *LLVMBB = cast<llvm::BasicBlock>(BB->Val);
895   return cast<llvm::PHINode>(Val)->getBasicBlockIndex(LLVMBB);
896 }
897 Value *PHINode::getIncomingValueForBlock(const BasicBlock *BB) const {
898   auto *LLVMBB = cast<llvm::BasicBlock>(BB->Val);
899   llvm::Value *LLVMV =
900       cast<llvm::PHINode>(Val)->getIncomingValueForBlock(LLVMBB);
901   return Ctx.getValue(LLVMV);
902 }
903 Value *PHINode::hasConstantValue() const {
904   llvm::Value *LLVMV = cast<llvm::PHINode>(Val)->hasConstantValue();
905   return LLVMV != nullptr ? Ctx.getValue(LLVMV) : nullptr;
906 }
907 void PHINode::replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New) {
908   assert(New && Old && "Sandbox IR PHI node got a null basic block!");
909   for (unsigned Idx = 0, NumOps = cast<llvm::PHINode>(Val)->getNumOperands();
910        Idx != NumOps; ++Idx)
911     if (getIncomingBlock(Idx) == Old)
912       setIncomingBlock(Idx, New);
913 }
914 void PHINode::removeIncomingValueIf(function_ref<bool(unsigned)> Predicate) {
915   // Avoid duplicate tracking by going through this->removeIncomingValue here at
916   // the expense of some performance. Copy PHI::removeIncomingValueIf more
917   // directly if performance becomes an issue.
918 
919   // Removing the element at index X, moves the element previously at X + 1
920   // to X. Working from the end avoids complications from that.
921   unsigned Idx = getNumIncomingValues();
922   while (Idx > 0) {
923     if (Predicate(Idx - 1))
924       removeIncomingValue(Idx - 1);
925     --Idx;
926   }
927 }
928 
929 Value *CmpInst::create(Predicate P, Value *S1, Value *S2, InsertPosition Pos,
930                        Context &Ctx, const Twine &Name) {
931   auto &Builder = setInsertPos(Pos);
932   auto *LLVMV = Builder.CreateCmp(P, S1->Val, S2->Val, Name);
933   // It may have been folded into a constant.
934   if (auto *LLVMC = dyn_cast<llvm::Constant>(LLVMV))
935     return Ctx.getOrCreateConstant(LLVMC);
936   if (isa<llvm::ICmpInst>(LLVMV))
937     return Ctx.createICmpInst(cast<llvm::ICmpInst>(LLVMV));
938   return Ctx.createFCmpInst(cast<llvm::FCmpInst>(LLVMV));
939 }
940 
941 Value *CmpInst::createWithCopiedFlags(Predicate P, Value *S1, Value *S2,
942                                       const Instruction *F, InsertPosition Pos,
943                                       Context &Ctx, const Twine &Name) {
944   Value *V = create(P, S1, S2, Pos, Ctx, Name);
945   if (auto *C = dyn_cast<Constant>(V))
946     return C;
947   cast<llvm::CmpInst>(V->Val)->copyIRFlags(F->Val);
948   return V;
949 }
950 
951 Type *CmpInst::makeCmpResultType(Type *OpndType) {
952   if (auto *VT = dyn_cast<VectorType>(OpndType)) {
953     // TODO: Cleanup when we have more complete support for
954     // sandboxir::VectorType
955     return OpndType->getContext().getType(llvm::VectorType::get(
956         llvm::Type::getInt1Ty(OpndType->getContext().LLVMCtx),
957         cast<llvm::VectorType>(VT->LLVMTy)->getElementCount()));
958   }
959   return Type::getInt1Ty(OpndType->getContext());
960 }
961 
962 void CmpInst::setPredicate(Predicate P) {
963   Ctx.getTracker()
964       .emplaceIfTracking<
965           GenericSetter<&CmpInst::getPredicate, &CmpInst::setPredicate>>(this);
966   cast<llvm::CmpInst>(Val)->setPredicate(P);
967 }
968 
969 void CmpInst::swapOperands() {
970   if (ICmpInst *IC = dyn_cast<ICmpInst>(this))
971     IC->swapOperands();
972   else
973     cast<FCmpInst>(this)->swapOperands();
974 }
975 
976 void ICmpInst::swapOperands() {
977   Ctx.getTracker().emplaceIfTracking<CmpSwapOperands>(this);
978   cast<llvm::ICmpInst>(Val)->swapOperands();
979 }
980 
981 void FCmpInst::swapOperands() {
982   Ctx.getTracker().emplaceIfTracking<CmpSwapOperands>(this);
983   cast<llvm::FCmpInst>(Val)->swapOperands();
984 }
985 
986 #ifndef NDEBUG
987 void CmpInst::dumpOS(raw_ostream &OS) const {
988   dumpCommonPrefix(OS);
989   dumpCommonSuffix(OS);
990 }
991 
992 void CmpInst::dump() const {
993   dumpOS(dbgs());
994   dbgs() << "\n";
995 }
996 #endif // NDEBUG
997 
998 static llvm::Instruction::CastOps getLLVMCastOp(Instruction::Opcode Opc) {
999   switch (Opc) {
1000   case Instruction::Opcode::ZExt:
1001     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::ZExt);
1002   case Instruction::Opcode::SExt:
1003     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::SExt);
1004   case Instruction::Opcode::FPToUI:
1005     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::FPToUI);
1006   case Instruction::Opcode::FPToSI:
1007     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::FPToSI);
1008   case Instruction::Opcode::FPExt:
1009     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::FPExt);
1010   case Instruction::Opcode::PtrToInt:
1011     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::PtrToInt);
1012   case Instruction::Opcode::IntToPtr:
1013     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::IntToPtr);
1014   case Instruction::Opcode::SIToFP:
1015     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::SIToFP);
1016   case Instruction::Opcode::UIToFP:
1017     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::UIToFP);
1018   case Instruction::Opcode::Trunc:
1019     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::Trunc);
1020   case Instruction::Opcode::FPTrunc:
1021     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::FPTrunc);
1022   case Instruction::Opcode::BitCast:
1023     return static_cast<llvm::Instruction::CastOps>(llvm::Instruction::BitCast);
1024   case Instruction::Opcode::AddrSpaceCast:
1025     return static_cast<llvm::Instruction::CastOps>(
1026         llvm::Instruction::AddrSpaceCast);
1027   default:
1028     llvm_unreachable("Opcode not suitable for CastInst!");
1029   }
1030 }
1031 
1032 /// \Returns the LLVM opcode that corresponds to \p Opc.
1033 static llvm::Instruction::UnaryOps getLLVMUnaryOp(Instruction::Opcode Opc) {
1034   switch (Opc) {
1035   case Instruction::Opcode::FNeg:
1036     return static_cast<llvm::Instruction::UnaryOps>(llvm::Instruction::FNeg);
1037   default:
1038     llvm_unreachable("Not a unary op!");
1039   }
1040 }
1041 
1042 CatchSwitchInst *CatchSwitchInst::create(Value *ParentPad, BasicBlock *UnwindBB,
1043                                          unsigned NumHandlers,
1044                                          InsertPosition Pos, Context &Ctx,
1045                                          const Twine &Name) {
1046   auto &Builder = setInsertPos(Pos);
1047   llvm::CatchSwitchInst *LLVMCSI = Builder.CreateCatchSwitch(
1048       ParentPad->Val, cast<llvm::BasicBlock>(UnwindBB->Val), NumHandlers, Name);
1049   return Ctx.createCatchSwitchInst(LLVMCSI);
1050 }
1051 
1052 Value *CatchSwitchInst::getParentPad() const {
1053   return Ctx.getValue(cast<llvm::CatchSwitchInst>(Val)->getParentPad());
1054 }
1055 
1056 void CatchSwitchInst::setParentPad(Value *ParentPad) {
1057   Ctx.getTracker()
1058       .emplaceIfTracking<GenericSetter<&CatchSwitchInst::getParentPad,
1059                                        &CatchSwitchInst::setParentPad>>(this);
1060   cast<llvm::CatchSwitchInst>(Val)->setParentPad(ParentPad->Val);
1061 }
1062 
1063 BasicBlock *CatchSwitchInst::getUnwindDest() const {
1064   return cast_or_null<BasicBlock>(
1065       Ctx.getValue(cast<llvm::CatchSwitchInst>(Val)->getUnwindDest()));
1066 }
1067 
1068 void CatchSwitchInst::setUnwindDest(BasicBlock *UnwindDest) {
1069   Ctx.getTracker()
1070       .emplaceIfTracking<GenericSetter<&CatchSwitchInst::getUnwindDest,
1071                                        &CatchSwitchInst::setUnwindDest>>(this);
1072   cast<llvm::CatchSwitchInst>(Val)->setUnwindDest(
1073       cast<llvm::BasicBlock>(UnwindDest->Val));
1074 }
1075 
1076 void CatchSwitchInst::addHandler(BasicBlock *Dest) {
1077   Ctx.getTracker().emplaceIfTracking<CatchSwitchAddHandler>(this);
1078   cast<llvm::CatchSwitchInst>(Val)->addHandler(
1079       cast<llvm::BasicBlock>(Dest->Val));
1080 }
1081 
1082 ResumeInst *ResumeInst::create(Value *Exn, InsertPosition Pos, Context &Ctx) {
1083   auto &Builder = setInsertPos(Pos);
1084   auto *LLVMI = cast<llvm::ResumeInst>(Builder.CreateResume(Exn->Val));
1085   return Ctx.createResumeInst(LLVMI);
1086 }
1087 
1088 Value *ResumeInst::getValue() const {
1089   return Ctx.getValue(cast<llvm::ResumeInst>(Val)->getValue());
1090 }
1091 
1092 SwitchInst *SwitchInst::create(Value *V, BasicBlock *Dest, unsigned NumCases,
1093                                InsertPosition Pos, Context &Ctx,
1094                                const Twine &Name) {
1095   auto &Builder = setInsertPos(Pos);
1096   llvm::SwitchInst *LLVMSwitch =
1097       Builder.CreateSwitch(V->Val, cast<llvm::BasicBlock>(Dest->Val), NumCases);
1098   return Ctx.createSwitchInst(LLVMSwitch);
1099 }
1100 
1101 Value *SwitchInst::getCondition() const {
1102   return Ctx.getValue(cast<llvm::SwitchInst>(Val)->getCondition());
1103 }
1104 
1105 void SwitchInst::setCondition(Value *V) {
1106   Ctx.getTracker()
1107       .emplaceIfTracking<
1108           GenericSetter<&SwitchInst::getCondition, &SwitchInst::setCondition>>(
1109           this);
1110   cast<llvm::SwitchInst>(Val)->setCondition(V->Val);
1111 }
1112 
1113 BasicBlock *SwitchInst::getDefaultDest() const {
1114   return cast<BasicBlock>(
1115       Ctx.getValue(cast<llvm::SwitchInst>(Val)->getDefaultDest()));
1116 }
1117 
1118 void SwitchInst::setDefaultDest(BasicBlock *DefaultCase) {
1119   Ctx.getTracker()
1120       .emplaceIfTracking<GenericSetter<&SwitchInst::getDefaultDest,
1121                                        &SwitchInst::setDefaultDest>>(this);
1122   cast<llvm::SwitchInst>(Val)->setDefaultDest(
1123       cast<llvm::BasicBlock>(DefaultCase->Val));
1124 }
1125 ConstantInt *SwitchInst::findCaseDest(BasicBlock *BB) {
1126   auto *LLVMC = cast<llvm::SwitchInst>(Val)->findCaseDest(
1127       cast<llvm::BasicBlock>(BB->Val));
1128   return LLVMC != nullptr ? cast<ConstantInt>(Ctx.getValue(LLVMC)) : nullptr;
1129 }
1130 
1131 void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
1132   Ctx.getTracker().emplaceIfTracking<SwitchAddCase>(this, OnVal);
1133   // TODO: Track this!
1134   cast<llvm::SwitchInst>(Val)->addCase(cast<llvm::ConstantInt>(OnVal->Val),
1135                                        cast<llvm::BasicBlock>(Dest->Val));
1136 }
1137 
1138 SwitchInst::CaseIt SwitchInst::removeCase(CaseIt It) {
1139   Ctx.getTracker().emplaceIfTracking<SwitchRemoveCase>(this);
1140 
1141   auto *LLVMSwitch = cast<llvm::SwitchInst>(Val);
1142   unsigned CaseNum = It - case_begin();
1143   llvm::SwitchInst::CaseIt LLVMIt(LLVMSwitch, CaseNum);
1144   auto LLVMCaseIt = LLVMSwitch->removeCase(LLVMIt);
1145   unsigned Num = LLVMCaseIt - LLVMSwitch->case_begin();
1146   return CaseIt(this, Num);
1147 }
1148 
1149 BasicBlock *SwitchInst::getSuccessor(unsigned Idx) const {
1150   return cast<BasicBlock>(
1151       Ctx.getValue(cast<llvm::SwitchInst>(Val)->getSuccessor(Idx)));
1152 }
1153 
1154 void SwitchInst::setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
1155   Ctx.getTracker()
1156       .emplaceIfTracking<GenericSetterWithIdx<&SwitchInst::getSuccessor,
1157                                               &SwitchInst::setSuccessor>>(this,
1158                                                                           Idx);
1159   cast<llvm::SwitchInst>(Val)->setSuccessor(
1160       Idx, cast<llvm::BasicBlock>(NewSucc->Val));
1161 }
1162 
1163 Value *UnaryOperator::create(Instruction::Opcode Op, Value *OpV,
1164                              InsertPosition Pos, Context &Ctx,
1165                              const Twine &Name) {
1166   auto &Builder = setInsertPos(Pos);
1167   auto *NewLLVMV = Builder.CreateUnOp(getLLVMUnaryOp(Op), OpV->Val, Name);
1168   if (auto *NewUnOpV = dyn_cast<llvm::UnaryOperator>(NewLLVMV)) {
1169     return Ctx.createUnaryOperator(NewUnOpV);
1170   }
1171   assert(isa<llvm::Constant>(NewLLVMV) && "Expected constant");
1172   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewLLVMV));
1173 }
1174 
1175 Value *UnaryOperator::createWithCopiedFlags(Instruction::Opcode Op, Value *OpV,
1176                                             Value *CopyFrom, InsertPosition Pos,
1177                                             Context &Ctx, const Twine &Name) {
1178   auto *NewV = create(Op, OpV, Pos, Ctx, Name);
1179   if (auto *UnI = dyn_cast<llvm::UnaryOperator>(NewV->Val))
1180     UnI->copyIRFlags(CopyFrom->Val);
1181   return NewV;
1182 }
1183 
1184 /// \Returns the LLVM opcode that corresponds to \p Opc.
1185 static llvm::Instruction::BinaryOps getLLVMBinaryOp(Instruction::Opcode Opc) {
1186   switch (Opc) {
1187   case Instruction::Opcode::Add:
1188     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::Add);
1189   case Instruction::Opcode::FAdd:
1190     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::FAdd);
1191   case Instruction::Opcode::Sub:
1192     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::Sub);
1193   case Instruction::Opcode::FSub:
1194     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::FSub);
1195   case Instruction::Opcode::Mul:
1196     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::Mul);
1197   case Instruction::Opcode::FMul:
1198     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::FMul);
1199   case Instruction::Opcode::UDiv:
1200     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::UDiv);
1201   case Instruction::Opcode::SDiv:
1202     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::SDiv);
1203   case Instruction::Opcode::FDiv:
1204     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::FDiv);
1205   case Instruction::Opcode::URem:
1206     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::URem);
1207   case Instruction::Opcode::SRem:
1208     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::SRem);
1209   case Instruction::Opcode::FRem:
1210     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::FRem);
1211   case Instruction::Opcode::Shl:
1212     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::Shl);
1213   case Instruction::Opcode::LShr:
1214     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::LShr);
1215   case Instruction::Opcode::AShr:
1216     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::AShr);
1217   case Instruction::Opcode::And:
1218     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::And);
1219   case Instruction::Opcode::Or:
1220     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::Or);
1221   case Instruction::Opcode::Xor:
1222     return static_cast<llvm::Instruction::BinaryOps>(llvm::Instruction::Xor);
1223   default:
1224     llvm_unreachable("Not a binary op!");
1225   }
1226 }
1227 Value *BinaryOperator::create(Instruction::Opcode Op, Value *LHS, Value *RHS,
1228                               InsertPosition Pos, Context &Ctx,
1229                               const Twine &Name) {
1230   auto &Builder = setInsertPos(Pos);
1231   llvm::Value *NewV =
1232       Builder.CreateBinOp(getLLVMBinaryOp(Op), LHS->Val, RHS->Val, Name);
1233   if (auto *NewBinOp = dyn_cast<llvm::BinaryOperator>(NewV))
1234     return Ctx.createBinaryOperator(NewBinOp);
1235   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1236   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1237 }
1238 
1239 Value *BinaryOperator::createWithCopiedFlags(Instruction::Opcode Op, Value *LHS,
1240                                              Value *RHS, Value *CopyFrom,
1241                                              InsertPosition Pos, Context &Ctx,
1242                                              const Twine &Name) {
1243 
1244   Value *NewV = create(Op, LHS, RHS, Pos, Ctx, Name);
1245   if (auto *NewBO = dyn_cast<BinaryOperator>(NewV))
1246     cast<llvm::BinaryOperator>(NewBO->Val)->copyIRFlags(CopyFrom->Val);
1247   return NewV;
1248 }
1249 
1250 void PossiblyDisjointInst::setIsDisjoint(bool B) {
1251   Ctx.getTracker()
1252       .emplaceIfTracking<GenericSetter<&PossiblyDisjointInst::isDisjoint,
1253                                        &PossiblyDisjointInst::setIsDisjoint>>(
1254           this);
1255   cast<llvm::PossiblyDisjointInst>(Val)->setIsDisjoint(B);
1256 }
1257 
1258 void AtomicRMWInst::setAlignment(Align Align) {
1259   Ctx.getTracker()
1260       .emplaceIfTracking<GenericSetter<&AtomicRMWInst::getAlign,
1261                                        &AtomicRMWInst::setAlignment>>(this);
1262   cast<llvm::AtomicRMWInst>(Val)->setAlignment(Align);
1263 }
1264 
1265 void AtomicRMWInst::setVolatile(bool V) {
1266   Ctx.getTracker()
1267       .emplaceIfTracking<GenericSetter<&AtomicRMWInst::isVolatile,
1268                                        &AtomicRMWInst::setVolatile>>(this);
1269   cast<llvm::AtomicRMWInst>(Val)->setVolatile(V);
1270 }
1271 
1272 void AtomicRMWInst::setOrdering(AtomicOrdering Ordering) {
1273   Ctx.getTracker()
1274       .emplaceIfTracking<GenericSetter<&AtomicRMWInst::getOrdering,
1275                                        &AtomicRMWInst::setOrdering>>(this);
1276   cast<llvm::AtomicRMWInst>(Val)->setOrdering(Ordering);
1277 }
1278 
1279 void AtomicRMWInst::setSyncScopeID(SyncScope::ID SSID) {
1280   Ctx.getTracker()
1281       .emplaceIfTracking<GenericSetter<&AtomicRMWInst::getSyncScopeID,
1282                                        &AtomicRMWInst::setSyncScopeID>>(this);
1283   cast<llvm::AtomicRMWInst>(Val)->setSyncScopeID(SSID);
1284 }
1285 
1286 Value *AtomicRMWInst::getPointerOperand() {
1287   return Ctx.getValue(cast<llvm::AtomicRMWInst>(Val)->getPointerOperand());
1288 }
1289 
1290 Value *AtomicRMWInst::getValOperand() {
1291   return Ctx.getValue(cast<llvm::AtomicRMWInst>(Val)->getValOperand());
1292 }
1293 
1294 AtomicRMWInst *AtomicRMWInst::create(BinOp Op, Value *Ptr, Value *Val,
1295                                      MaybeAlign Align, AtomicOrdering Ordering,
1296                                      InsertPosition Pos, Context &Ctx,
1297                                      SyncScope::ID SSID, const Twine &Name) {
1298   auto &Builder = setInsertPos(Pos);
1299   auto *LLVMAtomicRMW =
1300       Builder.CreateAtomicRMW(Op, Ptr->Val, Val->Val, Align, Ordering, SSID);
1301   LLVMAtomicRMW->setName(Name);
1302   return Ctx.createAtomicRMWInst(LLVMAtomicRMW);
1303 }
1304 
1305 void AtomicCmpXchgInst::setSyncScopeID(SyncScope::ID SSID) {
1306   Ctx.getTracker()
1307       .emplaceIfTracking<GenericSetter<&AtomicCmpXchgInst::getSyncScopeID,
1308                                        &AtomicCmpXchgInst::setSyncScopeID>>(
1309           this);
1310   cast<llvm::AtomicCmpXchgInst>(Val)->setSyncScopeID(SSID);
1311 }
1312 
1313 Value *AtomicCmpXchgInst::getPointerOperand() {
1314   return Ctx.getValue(cast<llvm::AtomicCmpXchgInst>(Val)->getPointerOperand());
1315 }
1316 
1317 Value *AtomicCmpXchgInst::getCompareOperand() {
1318   return Ctx.getValue(cast<llvm::AtomicCmpXchgInst>(Val)->getCompareOperand());
1319 }
1320 
1321 Value *AtomicCmpXchgInst::getNewValOperand() {
1322   return Ctx.getValue(cast<llvm::AtomicCmpXchgInst>(Val)->getNewValOperand());
1323 }
1324 
1325 AtomicCmpXchgInst *
1326 AtomicCmpXchgInst::create(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align,
1327                           AtomicOrdering SuccessOrdering,
1328                           AtomicOrdering FailureOrdering, InsertPosition Pos,
1329                           Context &Ctx, SyncScope::ID SSID, const Twine &Name) {
1330   auto &Builder = setInsertPos(Pos);
1331   auto *LLVMAtomicCmpXchg =
1332       Builder.CreateAtomicCmpXchg(Ptr->Val, Cmp->Val, New->Val, Align,
1333                                   SuccessOrdering, FailureOrdering, SSID);
1334   LLVMAtomicCmpXchg->setName(Name);
1335   return Ctx.createAtomicCmpXchgInst(LLVMAtomicCmpXchg);
1336 }
1337 
1338 void AtomicCmpXchgInst::setAlignment(Align Align) {
1339   Ctx.getTracker()
1340       .emplaceIfTracking<GenericSetter<&AtomicCmpXchgInst::getAlign,
1341                                        &AtomicCmpXchgInst::setAlignment>>(this);
1342   cast<llvm::AtomicCmpXchgInst>(Val)->setAlignment(Align);
1343 }
1344 
1345 void AtomicCmpXchgInst::setVolatile(bool V) {
1346   Ctx.getTracker()
1347       .emplaceIfTracking<GenericSetter<&AtomicCmpXchgInst::isVolatile,
1348                                        &AtomicCmpXchgInst::setVolatile>>(this);
1349   cast<llvm::AtomicCmpXchgInst>(Val)->setVolatile(V);
1350 }
1351 
1352 void AtomicCmpXchgInst::setWeak(bool IsWeak) {
1353   Ctx.getTracker()
1354       .emplaceIfTracking<GenericSetter<&AtomicCmpXchgInst::isWeak,
1355                                        &AtomicCmpXchgInst::setWeak>>(this);
1356   cast<llvm::AtomicCmpXchgInst>(Val)->setWeak(IsWeak);
1357 }
1358 
1359 void AtomicCmpXchgInst::setSuccessOrdering(AtomicOrdering Ordering) {
1360   Ctx.getTracker()
1361       .emplaceIfTracking<GenericSetter<&AtomicCmpXchgInst::getSuccessOrdering,
1362                                        &AtomicCmpXchgInst::setSuccessOrdering>>(
1363           this);
1364   cast<llvm::AtomicCmpXchgInst>(Val)->setSuccessOrdering(Ordering);
1365 }
1366 
1367 void AtomicCmpXchgInst::setFailureOrdering(AtomicOrdering Ordering) {
1368   Ctx.getTracker()
1369       .emplaceIfTracking<GenericSetter<&AtomicCmpXchgInst::getFailureOrdering,
1370                                        &AtomicCmpXchgInst::setFailureOrdering>>(
1371           this);
1372   cast<llvm::AtomicCmpXchgInst>(Val)->setFailureOrdering(Ordering);
1373 }
1374 
1375 AllocaInst *AllocaInst::create(Type *Ty, unsigned AddrSpace, InsertPosition Pos,
1376                                Context &Ctx, Value *ArraySize,
1377                                const Twine &Name) {
1378   auto &Builder = setInsertPos(Pos);
1379   auto *NewAlloca =
1380       Builder.CreateAlloca(Ty->LLVMTy, AddrSpace, ArraySize->Val, Name);
1381   return Ctx.createAllocaInst(NewAlloca);
1382 }
1383 
1384 Type *AllocaInst::getAllocatedType() const {
1385   return Ctx.getType(cast<llvm::AllocaInst>(Val)->getAllocatedType());
1386 }
1387 
1388 void AllocaInst::setAllocatedType(Type *Ty) {
1389   Ctx.getTracker()
1390       .emplaceIfTracking<GenericSetter<&AllocaInst::getAllocatedType,
1391                                        &AllocaInst::setAllocatedType>>(this);
1392   cast<llvm::AllocaInst>(Val)->setAllocatedType(Ty->LLVMTy);
1393 }
1394 
1395 void AllocaInst::setAlignment(Align Align) {
1396   Ctx.getTracker()
1397       .emplaceIfTracking<
1398           GenericSetter<&AllocaInst::getAlign, &AllocaInst::setAlignment>>(
1399           this);
1400   cast<llvm::AllocaInst>(Val)->setAlignment(Align);
1401 }
1402 
1403 void AllocaInst::setUsedWithInAlloca(bool V) {
1404   Ctx.getTracker()
1405       .emplaceIfTracking<GenericSetter<&AllocaInst::isUsedWithInAlloca,
1406                                        &AllocaInst::setUsedWithInAlloca>>(this);
1407   cast<llvm::AllocaInst>(Val)->setUsedWithInAlloca(V);
1408 }
1409 
1410 Value *AllocaInst::getArraySize() {
1411   return Ctx.getValue(cast<llvm::AllocaInst>(Val)->getArraySize());
1412 }
1413 
1414 PointerType *AllocaInst::getType() const {
1415   return cast<PointerType>(Ctx.getType(cast<llvm::AllocaInst>(Val)->getType()));
1416 }
1417 
1418 Value *CastInst::create(Type *DestTy, Opcode Op, Value *Operand,
1419                         InsertPosition Pos, Context &Ctx, const Twine &Name) {
1420   assert(getLLVMCastOp(Op) && "Opcode not suitable for CastInst!");
1421   auto &Builder = setInsertPos(Pos);
1422   auto *NewV =
1423       Builder.CreateCast(getLLVMCastOp(Op), Operand->Val, DestTy->LLVMTy, Name);
1424   if (auto *NewCI = dyn_cast<llvm::CastInst>(NewV))
1425     return Ctx.createCastInst(NewCI);
1426   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1427   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1428 }
1429 
1430 bool CastInst::classof(const Value *From) {
1431   return From->getSubclassID() == ClassID::Cast;
1432 }
1433 
1434 Type *CastInst::getSrcTy() const {
1435   return Ctx.getType(cast<llvm::CastInst>(Val)->getSrcTy());
1436 }
1437 
1438 Type *CastInst::getDestTy() const {
1439   return Ctx.getType(cast<llvm::CastInst>(Val)->getDestTy());
1440 }
1441 
1442 void PossiblyNonNegInst::setNonNeg(bool B) {
1443   Ctx.getTracker()
1444       .emplaceIfTracking<GenericSetter<&PossiblyNonNegInst::hasNonNeg,
1445                                        &PossiblyNonNegInst::setNonNeg>>(this);
1446   cast<llvm::PossiblyNonNegInst>(Val)->setNonNeg(B);
1447 }
1448 
1449 Value *InsertElementInst::create(Value *Vec, Value *NewElt, Value *Idx,
1450                                  InsertPosition Pos, Context &Ctx,
1451                                  const Twine &Name) {
1452   auto &Builder = Instruction::setInsertPos(Pos);
1453   llvm::Value *NewV =
1454       Builder.CreateInsertElement(Vec->Val, NewElt->Val, Idx->Val, Name);
1455   if (auto *NewInsert = dyn_cast<llvm::InsertElementInst>(NewV))
1456     return Ctx.createInsertElementInst(NewInsert);
1457   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1458   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1459 }
1460 
1461 Value *ExtractElementInst::create(Value *Vec, Value *Idx, InsertPosition Pos,
1462                                   Context &Ctx, const Twine &Name) {
1463   auto &Builder = setInsertPos(Pos);
1464   llvm::Value *NewV = Builder.CreateExtractElement(Vec->Val, Idx->Val, Name);
1465   if (auto *NewExtract = dyn_cast<llvm::ExtractElementInst>(NewV))
1466     return Ctx.createExtractElementInst(NewExtract);
1467   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1468   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1469 }
1470 
1471 Value *ShuffleVectorInst::create(Value *V1, Value *V2, Value *Mask,
1472                                  InsertPosition Pos, Context &Ctx,
1473                                  const Twine &Name) {
1474   auto &Builder = setInsertPos(Pos);
1475   llvm::Value *NewV =
1476       Builder.CreateShuffleVector(V1->Val, V2->Val, Mask->Val, Name);
1477   if (auto *NewShuffle = dyn_cast<llvm::ShuffleVectorInst>(NewV))
1478     return Ctx.createShuffleVectorInst(NewShuffle);
1479   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1480   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1481 }
1482 
1483 Value *ShuffleVectorInst::create(Value *V1, Value *V2, ArrayRef<int> Mask,
1484                                  InsertPosition Pos, Context &Ctx,
1485                                  const Twine &Name) {
1486   auto &Builder = setInsertPos(Pos);
1487   llvm::Value *NewV = Builder.CreateShuffleVector(V1->Val, V2->Val, Mask, Name);
1488   if (auto *NewShuffle = dyn_cast<llvm::ShuffleVectorInst>(NewV))
1489     return Ctx.createShuffleVectorInst(NewShuffle);
1490   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1491   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1492 }
1493 
1494 void ShuffleVectorInst::setShuffleMask(ArrayRef<int> Mask) {
1495   Ctx.getTracker().emplaceIfTracking<ShuffleVectorSetMask>(this);
1496   cast<llvm::ShuffleVectorInst>(Val)->setShuffleMask(Mask);
1497 }
1498 
1499 VectorType *ShuffleVectorInst::getType() const {
1500   return cast<VectorType>(
1501       Ctx.getType(cast<llvm::ShuffleVectorInst>(Val)->getType()));
1502 }
1503 
1504 void ShuffleVectorInst::commute() {
1505   Ctx.getTracker().emplaceIfTracking<ShuffleVectorSetMask>(this);
1506   Ctx.getTracker().emplaceIfTracking<UseSwap>(getOperandUse(0),
1507                                               getOperandUse(1));
1508   cast<llvm::ShuffleVectorInst>(Val)->commute();
1509 }
1510 
1511 Constant *ShuffleVectorInst::getShuffleMaskForBitcode() const {
1512   return Ctx.getOrCreateConstant(
1513       cast<llvm::ShuffleVectorInst>(Val)->getShuffleMaskForBitcode());
1514 }
1515 
1516 Constant *ShuffleVectorInst::convertShuffleMaskForBitcode(ArrayRef<int> Mask,
1517                                                           Type *ResultTy) {
1518   return ResultTy->getContext().getOrCreateConstant(
1519       llvm::ShuffleVectorInst::convertShuffleMaskForBitcode(Mask,
1520                                                             ResultTy->LLVMTy));
1521 }
1522 
1523 VectorType *ExtractElementInst::getVectorOperandType() const {
1524   return cast<VectorType>(Ctx.getType(getVectorOperand()->getType()->LLVMTy));
1525 }
1526 
1527 Value *ExtractValueInst::create(Value *Agg, ArrayRef<unsigned> Idxs,
1528                                 InsertPosition Pos, Context &Ctx,
1529                                 const Twine &Name) {
1530   auto &Builder = setInsertPos(Pos);
1531   llvm::Value *NewV = Builder.CreateExtractValue(Agg->Val, Idxs, Name);
1532   if (auto *NewExtractValueInst = dyn_cast<llvm::ExtractValueInst>(NewV))
1533     return Ctx.createExtractValueInst(NewExtractValueInst);
1534   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1535   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1536 }
1537 
1538 Type *ExtractValueInst::getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs) {
1539   auto *LLVMTy = llvm::ExtractValueInst::getIndexedType(Agg->LLVMTy, Idxs);
1540   return Agg->getContext().getType(LLVMTy);
1541 }
1542 
1543 Value *InsertValueInst::create(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
1544                                InsertPosition Pos, Context &Ctx,
1545                                const Twine &Name) {
1546   auto &Builder = setInsertPos(Pos);
1547   llvm::Value *NewV = Builder.CreateInsertValue(Agg->Val, Val->Val, Idxs, Name);
1548   if (auto *NewInsertValueInst = dyn_cast<llvm::InsertValueInst>(NewV))
1549     return Ctx.createInsertValueInst(NewInsertValueInst);
1550   assert(isa<llvm::Constant>(NewV) && "Expected constant");
1551   return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
1552 }
1553 
1554 ConstantTokenNone *ConstantTokenNone::get(Context &Ctx) {
1555   auto *LLVMC = llvm::ConstantTokenNone::get(Ctx.LLVMCtx);
1556   return cast<ConstantTokenNone>(Ctx.getOrCreateConstant(LLVMC));
1557 }
1558 
1559 } // namespace llvm::sandboxir
1560