LLVM  8.0.0svn
Instruction.cpp
Go to the documentation of this file.
1 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Instruction class for the IR library.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/Instruction.h"
15 #include "llvm/IR/IntrinsicInst.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/Instructions.h"
19 #include "llvm/IR/MDBuilder.h"
20 #include "llvm/IR/Operator.h"
21 #include "llvm/IR/Type.h"
22 using namespace llvm;
23 
24 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
25  Instruction *InsertBefore)
26  : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
27 
28  // If requested, insert this instruction into a basic block...
29  if (InsertBefore) {
30  BasicBlock *BB = InsertBefore->getParent();
31  assert(BB && "Instruction to insert before is not in a basic block!");
32  BB->getInstList().insert(InsertBefore->getIterator(), this);
33  }
34 }
35 
36 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
37  BasicBlock *InsertAtEnd)
38  : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
39 
40  // append this instruction into the basic block
41  assert(InsertAtEnd && "Basic block to append to may not be NULL!");
42  InsertAtEnd->getInstList().push_back(this);
43 }
44 
46  assert(!Parent && "Instruction still linked in the program!");
47  if (hasMetadataHashEntry())
48  clearMetadataHashEntries();
49 }
50 
51 
52 void Instruction::setParent(BasicBlock *P) {
53  Parent = P;
54 }
55 
57  return getParent()->getModule();
58 }
59 
61  return getParent()->getParent();
62 }
63 
66 }
67 
69  return getParent()->getInstList().erase(getIterator());
70 }
71 
72 /// Insert an unlinked instruction into a basic block immediately before the
73 /// specified instruction.
75  InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this);
76 }
77 
78 /// Insert an unlinked instruction into a basic block immediately after the
79 /// specified instruction.
81  InsertPos->getParent()->getInstList().insertAfter(InsertPos->getIterator(),
82  this);
83 }
84 
85 /// Unlink this instruction from its current basic block and insert it into the
86 /// basic block that MovePos lives in, right before MovePos.
88  moveBefore(*MovePos->getParent(), MovePos->getIterator());
89 }
90 
92  moveBefore(*MovePos->getParent(), ++MovePos->getIterator());
93 }
94 
97  assert(I == BB.end() || I->getParent() == &BB);
98  BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
99 }
100 
102  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b);
103 }
104 
106  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b);
107 }
108 
110  cast<PossiblyExactOperator>(this)->setIsExact(b);
111 }
112 
114  return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap();
115 }
116 
118  return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
119 }
120 
122  switch (getOpcode()) {
123  case Instruction::Add:
124  case Instruction::Sub:
125  case Instruction::Mul:
126  case Instruction::Shl:
127  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(false);
128  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(false);
129  break;
130 
131  case Instruction::UDiv:
132  case Instruction::SDiv:
133  case Instruction::AShr:
134  case Instruction::LShr:
135  cast<PossiblyExactOperator>(this)->setIsExact(false);
136  break;
137 
138  case Instruction::GetElementPtr:
139  cast<GetElementPtrInst>(this)->setIsInBounds(false);
140  break;
141  }
142 }
143 
144 bool Instruction::isExact() const {
145  return cast<PossiblyExactOperator>(this)->isExact();
146 }
147 
149  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
150  cast<FPMathOperator>(this)->setFast(B);
151 }
152 
154  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
155  cast<FPMathOperator>(this)->setHasAllowReassoc(B);
156 }
157 
159  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
160  cast<FPMathOperator>(this)->setHasNoNaNs(B);
161 }
162 
164  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
165  cast<FPMathOperator>(this)->setHasNoInfs(B);
166 }
167 
169  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
170  cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
171 }
172 
174  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
175  cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
176 }
177 
179  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
180  cast<FPMathOperator>(this)->setHasApproxFunc(B);
181 }
182 
184  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
185  cast<FPMathOperator>(this)->setFastMathFlags(FMF);
186 }
187 
189  assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op");
190  cast<FPMathOperator>(this)->copyFastMathFlags(FMF);
191 }
192 
193 bool Instruction::isFast() const {
194  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
195  return cast<FPMathOperator>(this)->isFast();
196 }
197 
199  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
200  return cast<FPMathOperator>(this)->hasAllowReassoc();
201 }
202 
204  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
205  return cast<FPMathOperator>(this)->hasNoNaNs();
206 }
207 
209  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
210  return cast<FPMathOperator>(this)->hasNoInfs();
211 }
212 
214  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
215  return cast<FPMathOperator>(this)->hasNoSignedZeros();
216 }
217 
219  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
220  return cast<FPMathOperator>(this)->hasAllowReciprocal();
221 }
222 
224  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
225  return cast<FPMathOperator>(this)->hasAllowContract();
226 }
227 
229  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
230  return cast<FPMathOperator>(this)->hasApproxFunc();
231 }
232 
234  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
235  return cast<FPMathOperator>(this)->getFastMathFlags();
236 }
237 
240 }
241 
242 void Instruction::copyIRFlags(const Value *V, bool IncludeWrapFlags) {
243  // Copy the wrapping flags.
244  if (IncludeWrapFlags && isa<OverflowingBinaryOperator>(this)) {
245  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
246  setHasNoSignedWrap(OB->hasNoSignedWrap());
247  setHasNoUnsignedWrap(OB->hasNoUnsignedWrap());
248  }
249  }
250 
251  // Copy the exact flag.
252  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
253  if (isa<PossiblyExactOperator>(this))
254  setIsExact(PE->isExact());
255 
256  // Copy the fast-math flags.
257  if (auto *FP = dyn_cast<FPMathOperator>(V))
258  if (isa<FPMathOperator>(this))
259  copyFastMathFlags(FP->getFastMathFlags());
260 
261  if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
262  if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
263  DestGEP->setIsInBounds(SrcGEP->isInBounds() | DestGEP->isInBounds());
264 }
265 
267  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
268  if (isa<OverflowingBinaryOperator>(this)) {
269  setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap());
270  setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap());
271  }
272  }
273 
274  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
275  if (isa<PossiblyExactOperator>(this))
276  setIsExact(isExact() & PE->isExact());
277 
278  if (auto *FP = dyn_cast<FPMathOperator>(V)) {
279  if (isa<FPMathOperator>(this)) {
281  FM &= FP->getFastMathFlags();
282  copyFastMathFlags(FM);
283  }
284  }
285 
286  if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
287  if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
288  DestGEP->setIsInBounds(SrcGEP->isInBounds() & DestGEP->isInBounds());
289 }
290 
291 const char *Instruction::getOpcodeName(unsigned OpCode) {
292  switch (OpCode) {
293  // Terminators
294  case Ret: return "ret";
295  case Br: return "br";
296  case Switch: return "switch";
297  case IndirectBr: return "indirectbr";
298  case Invoke: return "invoke";
299  case Resume: return "resume";
300  case Unreachable: return "unreachable";
301  case CleanupRet: return "cleanupret";
302  case CatchRet: return "catchret";
303  case CatchPad: return "catchpad";
304  case CatchSwitch: return "catchswitch";
305 
306  // Standard unary operators...
307  case FNeg: return "fneg";
308 
309  // Standard binary operators...
310  case Add: return "add";
311  case FAdd: return "fadd";
312  case Sub: return "sub";
313  case FSub: return "fsub";
314  case Mul: return "mul";
315  case FMul: return "fmul";
316  case UDiv: return "udiv";
317  case SDiv: return "sdiv";
318  case FDiv: return "fdiv";
319  case URem: return "urem";
320  case SRem: return "srem";
321  case FRem: return "frem";
322 
323  // Logical operators...
324  case And: return "and";
325  case Or : return "or";
326  case Xor: return "xor";
327 
328  // Memory instructions...
329  case Alloca: return "alloca";
330  case Load: return "load";
331  case Store: return "store";
332  case AtomicCmpXchg: return "cmpxchg";
333  case AtomicRMW: return "atomicrmw";
334  case Fence: return "fence";
335  case GetElementPtr: return "getelementptr";
336 
337  // Convert instructions...
338  case Trunc: return "trunc";
339  case ZExt: return "zext";
340  case SExt: return "sext";
341  case FPTrunc: return "fptrunc";
342  case FPExt: return "fpext";
343  case FPToUI: return "fptoui";
344  case FPToSI: return "fptosi";
345  case UIToFP: return "uitofp";
346  case SIToFP: return "sitofp";
347  case IntToPtr: return "inttoptr";
348  case PtrToInt: return "ptrtoint";
349  case BitCast: return "bitcast";
350  case AddrSpaceCast: return "addrspacecast";
351 
352  // Other instructions...
353  case ICmp: return "icmp";
354  case FCmp: return "fcmp";
355  case PHI: return "phi";
356  case Select: return "select";
357  case Call: return "call";
358  case Shl: return "shl";
359  case LShr: return "lshr";
360  case AShr: return "ashr";
361  case VAArg: return "va_arg";
362  case ExtractElement: return "extractelement";
363  case InsertElement: return "insertelement";
364  case ShuffleVector: return "shufflevector";
365  case ExtractValue: return "extractvalue";
366  case InsertValue: return "insertvalue";
367  case LandingPad: return "landingpad";
368  case CleanupPad: return "cleanuppad";
369 
370  default: return "<Invalid operator> ";
371  }
372 }
373 
374 /// Return true if both instructions have the same special state. This must be
375 /// kept in sync with FunctionComparator::cmpOperations in
376 /// lib/Transforms/IPO/MergeFunctions.cpp.
377 static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2,
378  bool IgnoreAlignment = false) {
379  assert(I1->getOpcode() == I2->getOpcode() &&
380  "Can not compare special state of different instructions");
381 
382  if (const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
383  return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
384  (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
385  IgnoreAlignment);
386  if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
387  return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
388  (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
389  IgnoreAlignment) &&
390  LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
391  LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
392  if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
393  return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
394  (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
395  IgnoreAlignment) &&
396  SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
397  SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
398  if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
399  return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
400  if (const CallInst *CI = dyn_cast<CallInst>(I1))
401  return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
402  CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
403  CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
404  CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
405  if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
406  return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
407  CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
408  CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
409  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
410  return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
411  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
412  return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
413  if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
414  return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
415  FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
416  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
417  return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
418  CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
419  CXI->getSuccessOrdering() ==
420  cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
421  CXI->getFailureOrdering() ==
422  cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
423  CXI->getSyncScopeID() ==
424  cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
425  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
426  return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
427  RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
428  RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
429  RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
430 
431  return true;
432 }
433 
435  return isIdenticalToWhenDefined(I) &&
437 }
438 
440  if (getOpcode() != I->getOpcode() ||
441  getNumOperands() != I->getNumOperands() ||
442  getType() != I->getType())
443  return false;
444 
445  // If both instructions have no operands, they are identical.
446  if (getNumOperands() == 0 && I->getNumOperands() == 0)
447  return haveSameSpecialState(this, I);
448 
449  // We have two instructions of identical opcode and #operands. Check to see
450  // if all operands are the same.
451  if (!std::equal(op_begin(), op_end(), I->op_begin()))
452  return false;
453 
454  if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
455  const PHINode *otherPHI = cast<PHINode>(I);
456  return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
457  otherPHI->block_begin());
458  }
459 
460  return haveSameSpecialState(this, I);
461 }
462 
463 // Keep this in sync with FunctionComparator::cmpOperations in
464 // lib/Transforms/IPO/MergeFunctions.cpp.
466  unsigned flags) const {
467  bool IgnoreAlignment = flags & CompareIgnoringAlignment;
468  bool UseScalarTypes = flags & CompareUsingScalarTypes;
469 
470  if (getOpcode() != I->getOpcode() ||
471  getNumOperands() != I->getNumOperands() ||
472  (UseScalarTypes ?
473  getType()->getScalarType() != I->getType()->getScalarType() :
474  getType() != I->getType()))
475  return false;
476 
477  // We have two instructions of identical opcode and #operands. Check to see
478  // if all operands are the same type
479  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
480  if (UseScalarTypes ?
481  getOperand(i)->getType()->getScalarType() !=
482  I->getOperand(i)->getType()->getScalarType() :
483  getOperand(i)->getType() != I->getOperand(i)->getType())
484  return false;
485 
486  return haveSameSpecialState(this, I, IgnoreAlignment);
487 }
488 
490  for (const Use &U : uses()) {
491  // PHI nodes uses values in the corresponding predecessor block. For other
492  // instructions, just check to see whether the parent of the use matches up.
493  const Instruction *I = cast<Instruction>(U.getUser());
494  const PHINode *PN = dyn_cast<PHINode>(I);
495  if (!PN) {
496  if (I->getParent() != BB)
497  return true;
498  continue;
499  }
500 
501  if (PN->getIncomingBlock(U) != BB)
502  return true;
503  }
504  return false;
505 }
506 
508  switch (getOpcode()) {
509  default: return false;
510  case Instruction::VAArg:
511  case Instruction::Load:
512  case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory
513  case Instruction::AtomicCmpXchg:
514  case Instruction::AtomicRMW:
515  case Instruction::CatchPad:
516  case Instruction::CatchRet:
517  return true;
518  case Instruction::Call:
519  return !cast<CallInst>(this)->doesNotAccessMemory();
520  case Instruction::Invoke:
521  return !cast<InvokeInst>(this)->doesNotAccessMemory();
522  case Instruction::Store:
523  return !cast<StoreInst>(this)->isUnordered();
524  }
525 }
526 
528  switch (getOpcode()) {
529  default: return false;
530  case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory
531  case Instruction::Store:
532  case Instruction::VAArg:
533  case Instruction::AtomicCmpXchg:
534  case Instruction::AtomicRMW:
535  case Instruction::CatchPad:
536  case Instruction::CatchRet:
537  return true;
538  case Instruction::Call:
539  return !cast<CallInst>(this)->onlyReadsMemory();
540  case Instruction::Invoke:
541  return !cast<InvokeInst>(this)->onlyReadsMemory();
542  case Instruction::Load:
543  return !cast<LoadInst>(this)->isUnordered();
544  }
545 }
546 
547 bool Instruction::isAtomic() const {
548  switch (getOpcode()) {
549  default:
550  return false;
551  case Instruction::AtomicCmpXchg:
552  case Instruction::AtomicRMW:
553  case Instruction::Fence:
554  return true;
555  case Instruction::Load:
556  return cast<LoadInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
557  case Instruction::Store:
558  return cast<StoreInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
559  }
560 }
561 
563  assert(isAtomic());
564  switch (getOpcode()) {
565  default:
566  return false;
567  case Instruction::AtomicCmpXchg:
568  case Instruction::AtomicRMW:
569  case Instruction::Load:
570  return true;
571  }
572 }
573 
575  assert(isAtomic());
576  switch (getOpcode()) {
577  default:
578  return false;
579  case Instruction::AtomicCmpXchg:
580  case Instruction::AtomicRMW:
581  case Instruction::Store:
582  return true;
583  }
584 }
585 
586 bool Instruction::mayThrow() const {
587  if (const CallInst *CI = dyn_cast<CallInst>(this))
588  return !CI->doesNotThrow();
589  if (const auto *CRI = dyn_cast<CleanupReturnInst>(this))
590  return CRI->unwindsToCaller();
591  if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(this))
592  return CatchSwitch->unwindsToCaller();
593  return isa<ResumeInst>(this);
594 }
595 
597  return (!isa<CallInst>(this) || !this->mayHaveSideEffects()) &&
598  !this->isTerminator();
599 }
600 
602  for (const Instruction *I = getNextNode(); I; I = I->getNextNode())
603  if (!isa<DbgInfoIntrinsic>(I))
604  return I;
605  return nullptr;
606 }
607 
609  for (const Instruction *I = getPrevNode(); I; I = I->getPrevNode())
610  if (!isa<DbgInfoIntrinsic>(I))
611  return I;
612  return nullptr;
613 }
614 
616  unsigned Opcode = getOpcode();
617  if (isAssociative(Opcode))
618  return true;
619 
620  switch (Opcode) {
621  case FMul:
622  case FAdd:
623  return cast<FPMathOperator>(this)->hasAllowReassoc() &&
624  cast<FPMathOperator>(this)->hasNoSignedZeros();
625  default:
626  return false;
627  }
628 }
629 
631  switch (getOpcode()) {
632 #define HANDLE_TERM_INST(N, OPC, CLASS) \
633  case Instruction::OPC: \
634  return static_cast<const CLASS *>(this)->getNumSuccessors();
635 #include "llvm/IR/Instruction.def"
636  default:
637  break;
638  }
639  llvm_unreachable("not a terminator");
640 }
641 
642 BasicBlock *Instruction::getSuccessor(unsigned idx) const {
643  switch (getOpcode()) {
644 #define HANDLE_TERM_INST(N, OPC, CLASS) \
645  case Instruction::OPC: \
646  return static_cast<const CLASS *>(this)->getSuccessor(idx);
647 #include "llvm/IR/Instruction.def"
648  default:
649  break;
650  }
651  llvm_unreachable("not a terminator");
652 }
653 
654 void Instruction::setSuccessor(unsigned idx, BasicBlock *B) {
655  switch (getOpcode()) {
656 #define HANDLE_TERM_INST(N, OPC, CLASS) \
657  case Instruction::OPC: \
658  return static_cast<CLASS *>(this)->setSuccessor(idx, B);
659 #include "llvm/IR/Instruction.def"
660  default:
661  break;
662  }
663  llvm_unreachable("not a terminator");
664 }
665 
666 Instruction *Instruction::cloneImpl() const {
667  llvm_unreachable("Subclass of Instruction failed to implement cloneImpl");
668 }
669 
671  MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
672  if (!ProfileData || ProfileData->getNumOperands() != 3 ||
673  !isa<MDString>(ProfileData->getOperand(0)))
674  return;
675 
676  MDString *MDName = cast<MDString>(ProfileData->getOperand(0));
677  if (MDName->getString() != "branch_weights")
678  return;
679 
680  // The first operand is the name. Fetch them backwards and build a new one.
681  Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
682  ProfileData->getOperand(1)};
684  MDNode::get(ProfileData->getContext(), Ops));
685 }
686 
688  ArrayRef<unsigned> WL) {
689  if (!SrcInst.hasMetadata())
690  return;
691 
692  DenseSet<unsigned> WLS;
693  for (unsigned M : WL)
694  WLS.insert(M);
695 
696  // Otherwise, enumerate and copy over metadata from the old instruction to the
697  // new one.
699  SrcInst.getAllMetadataOtherThanDebugLoc(TheMDs);
700  for (const auto &MD : TheMDs) {
701  if (WL.empty() || WLS.count(MD.first))
702  setMetadata(MD.first, MD.second);
703  }
704  if (WL.empty() || WLS.count(LLVMContext::MD_dbg))
705  setDebugLoc(SrcInst.getDebugLoc());
706 }
707 
709  Instruction *New = nullptr;
710  switch (getOpcode()) {
711  default:
712  llvm_unreachable("Unhandled Opcode.");
713 #define HANDLE_INST(num, opc, clas) \
714  case Instruction::opc: \
715  New = cast<clas>(this)->cloneImpl(); \
716  break;
717 #include "llvm/IR/Instruction.def"
718 #undef HANDLE_INST
719  }
720 
722  New->copyMetadata(*this);
723  return New;
724 }
725 
726 void Instruction::updateProfWeight(uint64_t S, uint64_t T) {
727  auto *ProfileData = getMetadata(LLVMContext::MD_prof);
728  if (ProfileData == nullptr)
729  return;
730 
731  auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
732  if (!ProfDataName || (!ProfDataName->getString().equals("branch_weights") &&
733  !ProfDataName->getString().equals("VP")))
734  return;
735 
736  MDBuilder MDB(getContext());
738  Vals.push_back(ProfileData->getOperand(0));
739  APInt APS(128, S), APT(128, T);
740  if (ProfDataName->getString().equals("branch_weights"))
741  for (unsigned i = 1; i < ProfileData->getNumOperands(); i++) {
742  // Using APInt::div may be expensive, but most cases should fit 64 bits.
743  APInt Val(128,
744  mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i))
745  ->getValue()
746  .getZExtValue());
747  Val *= APS;
748  Vals.push_back(MDB.createConstant(
750  Val.udiv(APT).getLimitedValue())));
751  }
752  else if (ProfDataName->getString().equals("VP"))
753  for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
754  // The first value is the key of the value profile, which will not change.
755  Vals.push_back(ProfileData->getOperand(i));
756  // Using APInt::div may be expensive, but most cases should fit 64 bits.
757  APInt Val(128,
758  mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i + 1))
759  ->getValue()
760  .getZExtValue());
761  Val *= APS;
762  Vals.push_back(MDB.createConstant(
764  Val.udiv(APT).getLimitedValue())));
765  }
767 }
768 
770  assert((isa<CallInst>(this) || isa<InvokeInst>(this)) &&
771  "Can only set weights for call and invoke instrucitons");
772  SmallVector<uint32_t, 1> Weights;
773  Weights.push_back(W);
774  MDBuilder MDB(getContext());
776 }
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
This does the same thing as getAllMetadata, except that it filters out the debug location.
Definition: Instruction.h:244
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:68
bool hasNoInfs() const
Determine whether the no-infs flag is set.
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction, which must be an operator which supports these flags.
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:632
const Instruction * getPrevNonDebugInstruction() const
Return a pointer to the previous non-debug instruction in the same basic block as &#39;this&#39;...
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
iterator_range< use_iterator > uses()
Definition: Value.h:355
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
This instruction extracts a struct member or array element value from an aggregate value...
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const
This function determines if the specified instruction executes the same operation as the current one...
Instruction * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:289
iterator erase(iterator where)
Definition: ilist.h:267
This class represents lattice values for constants.
Definition: AllocatorList.h:24
bool isAtomic() const
Return true if this instruction has an AtomicOrdering of unordered or higher.
ConstantAsMetadata * createConstant(Constant *C)
Return the given constant as metadata.
Definition: MDBuilder.cpp:25
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
BasicBlock * getSuccessor(unsigned Idx) const
Return the specified successor. This instruction must be a terminator.
An instruction for ordering other memory operations.
Definition: Instructions.h:444
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:518
bool isSafeToRemove() const
Return true if the instruction can be removed if the result is unused.
void setProfWeight(uint64_t W)
Sets the branch_weights metadata to W for CallInst.
This class represents a function call, abstracting a target machine&#39;s calling convention.
void setHasNoNaNs(bool B)
Set or clear the no-nans flag on this instruction, which must be an operator which supports this flag...
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
bool hasAtomicLoad() const
Return true if this atomic instruction loads from memory.
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:705
bool isTerminator() const
Definition: Instruction.h:129
Metadata node.
Definition: Metadata.h:864
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1069
An instruction for reading from memory.
Definition: Instructions.h:168
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:177
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:681
void setSuccessor(unsigned Idx, BasicBlock *BB)
Update the specified successor to point at the provided block.
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
op_iterator op_begin()
Definition: User.h:230
bool isIdenticalTo(const Instruction *I) const
Return true if the specified instruction is exactly identical to the current one. ...
bool hasAllowContract() const
Determine whether the allow-contract flag is set.
void setHasApproxFunc(bool B)
Set or clear the approximate-math-functions flag on this instruction, which must be an operator which...
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
Definition: BasicBlock.cpp:134
static uint32_t getAlignment(const MCSectionCOFF &Sec)
bool hasAllowReciprocal() const
Determine whether the allow-reciprocal flag is set.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, bool IgnoreAlignment=false)
Return true if both instructions have the same special state.
void dropPoisonGeneratingFlags()
Drops flags that may cause this instruction to evaluate to poison despite having non-poison inputs...
bool hasApproxFunc() const
Determine whether the approximate-math-functions flag is set.
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
Definition: Instruction.h:211
Check for equivalence ignoring load/store alignment.
Definition: Instruction.h:622
block_iterator block_begin()
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
Instruction * clone() const
Create a copy of &#39;this&#39; instruction that is identical in all ways except the following: ...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
Check for equivalence treating a type and a vector of that type as equivalent.
Definition: Instruction.h:625
LLVMContext & getContext() const
Definition: Metadata.h:924
void andIRFlags(const Value *V)
Logical &#39;and&#39; of any supported wrapping, exact, and fast-math flags of V and this instruction...
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:221
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:126
An instruction for storing to memory.
Definition: Instructions.h:310
unsigned getNumSuccessors() const
Return the number of successors that this instruction has.
Value * getOperand(unsigned i) const
Definition: User.h:170
void setFast(bool B)
Set or clear all fast-math-flags on this instruction, which must be an operator which supports this f...
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return &#39;this&#39;.
Definition: Type.h:304
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
StringRef getString() const
Definition: Metadata.cpp:464
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1166
#define P(N)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:308
bool isIdenticalToWhenDefined(const Instruction *I) const
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags, which may specify conditions under which the instruction&#39;s result is undefined.
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction...
Definition: Instruction.cpp:74
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
const char * getOpcodeName() const
Definition: Instruction.h:128
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:188
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:562
bool mayThrow() const
Return true if this instruction may throw an exception.
const Instruction * getNextNonDebugInstruction() const
Return a pointer to the next non-debug instruction in the same basic block as &#39;this&#39;, or nullptr if no such instruction exists.
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
op_iterator op_end()
Definition: User.h:232
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:329
bool isFast() const
Determine whether all fast-math-flags are set.
self_iterator getIterator()
Definition: ilist_node.h:82
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:60
MDNode * createBranchWeights(uint32_t TrueWeight, uint32_t FalseWeight)
Return metadata containing two branch weights.
Definition: MDBuilder.cpp:38
bool isExact() const
Determine whether the exact flag is set.
void swapProfMetadata()
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1226
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:91
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:334
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
Definition: PPCPredicates.h:88
Iterator for intrusive lists based on ilist_node.
unsigned getNumOperands() const
Definition: User.h:192
void setHasAllowReassoc(bool B)
Set or clear the reassociation flag on this instruction, which must be an operator which supports thi...
iterator end()
Definition: BasicBlock.h:271
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
bool isUsedOutsideOfBlock(const BasicBlock *BB) const
Return true if there are any uses of this instruction in blocks other than the specified block...
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:622
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:56
Class for arbitrary precision integers.
Definition: APInt.h:70
void push_back(pointer val)
Definition: ilist.h:313
static bool isWeak(const MCSymbolELF &Sym)
void removeFromParent()
This method unlinks &#39;this&#39; from the containing basic block, but does not delete it.
Definition: Instruction.cpp:64
pointer remove(iterator &IT)
Definition: ilist.h:251
List that automatically updates parent links and symbol tables.
iterator insert(iterator where, pointer New)
Definition: ilist.h:228
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:311
void updateProfWeight(uint64_t S, uint64_t T)
Updates branch_weights metadata by scaling it by S / T.
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:80
#define I(x, y, z)
Definition: MD5.cpp:58
bool mayReadFromMemory() const
Return true if this instruction may read memory.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:92
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
Instruction(const Instruction &)=delete
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag...
bool hasAtomicStore() const
Return true if this atomic instruction stores to memory.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void moveAfter(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:91
LLVM Value Representation.
Definition: Value.h:73
bool hasAllowReassoc() const
Determine whether the allow-reassociation flag is set.
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:87
Invoke instruction.
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:160
A single uniqued string.
Definition: Metadata.h:604
static bool isVolatile(Instruction *Inst)
void setHasNoSignedZeros(bool B)
Set or clear the no-signed-zeros flag on this instruction, which must be an operator which supports t...
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1075
iterator insertAfter(iterator where, pointer New)
Definition: ilist.h:237
Root of the metadata hierarchy.
Definition: Metadata.h:58
void setHasAllowReciprocal(bool B)
Set or clear the allow-reciprocal flag on this instruction, which must be an operator which supports ...
const BasicBlock * getParent() const
Definition: Instruction.h:67
an instruction to allocate memory on the stack
Definition: Instructions.h:60
This instruction inserts a struct field of array element value into an aggregate value.