LLVM  7.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/ADT/DenseSet.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Instructions.h"
18 #include "llvm/IR/MDBuilder.h"
19 #include "llvm/IR/Operator.h"
20 #include "llvm/IR/Type.h"
21 using namespace llvm;
22 
23 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
24  Instruction *InsertBefore)
25  : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
26 
27  // If requested, insert this instruction into a basic block...
28  if (InsertBefore) {
29  BasicBlock *BB = InsertBefore->getParent();
30  assert(BB && "Instruction to insert before is not in a basic block!");
31  BB->getInstList().insert(InsertBefore->getIterator(), this);
32  }
33 }
34 
35 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
36  BasicBlock *InsertAtEnd)
37  : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
38 
39  // append this instruction into the basic block
40  assert(InsertAtEnd && "Basic block to append to may not be NULL!");
41  InsertAtEnd->getInstList().push_back(this);
42 }
43 
45  assert(!Parent && "Instruction still linked in the program!");
46  if (hasMetadataHashEntry())
47  clearMetadataHashEntries();
48 }
49 
50 
51 void Instruction::setParent(BasicBlock *P) {
52  Parent = P;
53 }
54 
56  return getParent()->getModule();
57 }
58 
60  return getParent()->getParent();
61 }
62 
65 }
66 
68  return getParent()->getInstList().erase(getIterator());
69 }
70 
71 /// Insert an unlinked instruction into a basic block immediately before the
72 /// specified instruction.
74  InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this);
75 }
76 
77 /// Insert an unlinked instruction into a basic block immediately after the
78 /// specified instruction.
80  InsertPos->getParent()->getInstList().insertAfter(InsertPos->getIterator(),
81  this);
82 }
83 
84 /// Unlink this instruction from its current basic block and insert it into the
85 /// basic block that MovePos lives in, right before MovePos.
87  moveBefore(*MovePos->getParent(), MovePos->getIterator());
88 }
89 
91  moveBefore(*MovePos->getParent(), ++MovePos->getIterator());
92 }
93 
96  assert(I == BB.end() || I->getParent() == &BB);
97  BB.getInstList().splice(I, getParent()->getInstList(), getIterator());
98 }
99 
101  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b);
102 }
103 
105  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b);
106 }
107 
109  cast<PossiblyExactOperator>(this)->setIsExact(b);
110 }
111 
113  return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap();
114 }
115 
117  return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
118 }
119 
121  switch (getOpcode()) {
122  case Instruction::Add:
123  case Instruction::Sub:
124  case Instruction::Mul:
125  case Instruction::Shl:
126  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(false);
127  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(false);
128  break;
129 
130  case Instruction::UDiv:
131  case Instruction::SDiv:
132  case Instruction::AShr:
133  case Instruction::LShr:
134  cast<PossiblyExactOperator>(this)->setIsExact(false);
135  break;
136 
137  case Instruction::GetElementPtr:
138  cast<GetElementPtrInst>(this)->setIsInBounds(false);
139  break;
140  }
141 }
142 
143 bool Instruction::isExact() const {
144  return cast<PossiblyExactOperator>(this)->isExact();
145 }
146 
148  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
149  cast<FPMathOperator>(this)->setFast(B);
150 }
151 
153  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
154  cast<FPMathOperator>(this)->setHasAllowReassoc(B);
155 }
156 
158  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
159  cast<FPMathOperator>(this)->setHasNoNaNs(B);
160 }
161 
163  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
164  cast<FPMathOperator>(this)->setHasNoInfs(B);
165 }
166 
168  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
169  cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
170 }
171 
173  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
174  cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
175 }
176 
178  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
179  cast<FPMathOperator>(this)->setHasApproxFunc(B);
180 }
181 
183  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
184  cast<FPMathOperator>(this)->setFastMathFlags(FMF);
185 }
186 
188  assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op");
189  cast<FPMathOperator>(this)->copyFastMathFlags(FMF);
190 }
191 
192 bool Instruction::isFast() const {
193  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
194  return cast<FPMathOperator>(this)->isFast();
195 }
196 
198  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
199  return cast<FPMathOperator>(this)->hasAllowReassoc();
200 }
201 
203  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
204  return cast<FPMathOperator>(this)->hasNoNaNs();
205 }
206 
208  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
209  return cast<FPMathOperator>(this)->hasNoInfs();
210 }
211 
213  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
214  return cast<FPMathOperator>(this)->hasNoSignedZeros();
215 }
216 
218  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
219  return cast<FPMathOperator>(this)->hasAllowReciprocal();
220 }
221 
223  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
224  return cast<FPMathOperator>(this)->hasAllowContract();
225 }
226 
228  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
229  return cast<FPMathOperator>(this)->hasApproxFunc();
230 }
231 
233  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
234  return cast<FPMathOperator>(this)->getFastMathFlags();
235 }
236 
239 }
240 
241 void Instruction::copyIRFlags(const Value *V, bool IncludeWrapFlags) {
242  // Copy the wrapping flags.
243  if (IncludeWrapFlags && isa<OverflowingBinaryOperator>(this)) {
244  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
245  setHasNoSignedWrap(OB->hasNoSignedWrap());
246  setHasNoUnsignedWrap(OB->hasNoUnsignedWrap());
247  }
248  }
249 
250  // Copy the exact flag.
251  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
252  if (isa<PossiblyExactOperator>(this))
253  setIsExact(PE->isExact());
254 
255  // Copy the fast-math flags.
256  if (auto *FP = dyn_cast<FPMathOperator>(V))
257  if (isa<FPMathOperator>(this))
258  copyFastMathFlags(FP->getFastMathFlags());
259 
260  if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
261  if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
262  DestGEP->setIsInBounds(SrcGEP->isInBounds() | DestGEP->isInBounds());
263 }
264 
266  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
267  if (isa<OverflowingBinaryOperator>(this)) {
268  setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap());
269  setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap());
270  }
271  }
272 
273  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
274  if (isa<PossiblyExactOperator>(this))
275  setIsExact(isExact() & PE->isExact());
276 
277  if (auto *FP = dyn_cast<FPMathOperator>(V)) {
278  if (isa<FPMathOperator>(this)) {
280  FM &= FP->getFastMathFlags();
281  copyFastMathFlags(FM);
282  }
283  }
284 
285  if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
286  if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
287  DestGEP->setIsInBounds(SrcGEP->isInBounds() & DestGEP->isInBounds());
288 }
289 
290 const char *Instruction::getOpcodeName(unsigned OpCode) {
291  switch (OpCode) {
292  // Terminators
293  case Ret: return "ret";
294  case Br: return "br";
295  case Switch: return "switch";
296  case IndirectBr: return "indirectbr";
297  case Invoke: return "invoke";
298  case Resume: return "resume";
299  case Unreachable: return "unreachable";
300  case CleanupRet: return "cleanupret";
301  case CatchRet: return "catchret";
302  case CatchPad: return "catchpad";
303  case CatchSwitch: return "catchswitch";
304 
305  // Standard binary operators...
306  case Add: return "add";
307  case FAdd: return "fadd";
308  case Sub: return "sub";
309  case FSub: return "fsub";
310  case Mul: return "mul";
311  case FMul: return "fmul";
312  case UDiv: return "udiv";
313  case SDiv: return "sdiv";
314  case FDiv: return "fdiv";
315  case URem: return "urem";
316  case SRem: return "srem";
317  case FRem: return "frem";
318 
319  // Logical operators...
320  case And: return "and";
321  case Or : return "or";
322  case Xor: return "xor";
323 
324  // Memory instructions...
325  case Alloca: return "alloca";
326  case Load: return "load";
327  case Store: return "store";
328  case AtomicCmpXchg: return "cmpxchg";
329  case AtomicRMW: return "atomicrmw";
330  case Fence: return "fence";
331  case GetElementPtr: return "getelementptr";
332 
333  // Convert instructions...
334  case Trunc: return "trunc";
335  case ZExt: return "zext";
336  case SExt: return "sext";
337  case FPTrunc: return "fptrunc";
338  case FPExt: return "fpext";
339  case FPToUI: return "fptoui";
340  case FPToSI: return "fptosi";
341  case UIToFP: return "uitofp";
342  case SIToFP: return "sitofp";
343  case IntToPtr: return "inttoptr";
344  case PtrToInt: return "ptrtoint";
345  case BitCast: return "bitcast";
346  case AddrSpaceCast: return "addrspacecast";
347 
348  // Other instructions...
349  case ICmp: return "icmp";
350  case FCmp: return "fcmp";
351  case PHI: return "phi";
352  case Select: return "select";
353  case Call: return "call";
354  case Shl: return "shl";
355  case LShr: return "lshr";
356  case AShr: return "ashr";
357  case VAArg: return "va_arg";
358  case ExtractElement: return "extractelement";
359  case InsertElement: return "insertelement";
360  case ShuffleVector: return "shufflevector";
361  case ExtractValue: return "extractvalue";
362  case InsertValue: return "insertvalue";
363  case LandingPad: return "landingpad";
364  case CleanupPad: return "cleanuppad";
365 
366  default: return "<Invalid operator> ";
367  }
368 }
369 
370 /// Return true if both instructions have the same special state. This must be
371 /// kept in sync with FunctionComparator::cmpOperations in
372 /// lib/Transforms/IPO/MergeFunctions.cpp.
373 static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2,
374  bool IgnoreAlignment = false) {
375  assert(I1->getOpcode() == I2->getOpcode() &&
376  "Can not compare special state of different instructions");
377 
378  if (const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
379  return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
380  (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
381  IgnoreAlignment);
382  if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
383  return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
384  (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
385  IgnoreAlignment) &&
386  LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
387  LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
388  if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
389  return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
390  (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
391  IgnoreAlignment) &&
392  SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
393  SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
394  if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
395  return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
396  if (const CallInst *CI = dyn_cast<CallInst>(I1))
397  return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
398  CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
399  CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
400  CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
401  if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
402  return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
403  CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
404  CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
405  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
406  return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
407  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
408  return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
409  if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
410  return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
411  FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
412  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
413  return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
414  CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
415  CXI->getSuccessOrdering() ==
416  cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
417  CXI->getFailureOrdering() ==
418  cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
419  CXI->getSyncScopeID() ==
420  cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
421  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
422  return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
423  RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
424  RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
425  RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
426 
427  return true;
428 }
429 
431  return isIdenticalToWhenDefined(I) &&
433 }
434 
436  if (getOpcode() != I->getOpcode() ||
437  getNumOperands() != I->getNumOperands() ||
438  getType() != I->getType())
439  return false;
440 
441  // If both instructions have no operands, they are identical.
442  if (getNumOperands() == 0 && I->getNumOperands() == 0)
443  return haveSameSpecialState(this, I);
444 
445  // We have two instructions of identical opcode and #operands. Check to see
446  // if all operands are the same.
447  if (!std::equal(op_begin(), op_end(), I->op_begin()))
448  return false;
449 
450  if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
451  const PHINode *otherPHI = cast<PHINode>(I);
452  return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
453  otherPHI->block_begin());
454  }
455 
456  return haveSameSpecialState(this, I);
457 }
458 
459 // Keep this in sync with FunctionComparator::cmpOperations in
460 // lib/Transforms/IPO/MergeFunctions.cpp.
462  unsigned flags) const {
463  bool IgnoreAlignment = flags & CompareIgnoringAlignment;
464  bool UseScalarTypes = flags & CompareUsingScalarTypes;
465 
466  if (getOpcode() != I->getOpcode() ||
467  getNumOperands() != I->getNumOperands() ||
468  (UseScalarTypes ?
469  getType()->getScalarType() != I->getType()->getScalarType() :
470  getType() != I->getType()))
471  return false;
472 
473  // We have two instructions of identical opcode and #operands. Check to see
474  // if all operands are the same type
475  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
476  if (UseScalarTypes ?
477  getOperand(i)->getType()->getScalarType() !=
478  I->getOperand(i)->getType()->getScalarType() :
479  getOperand(i)->getType() != I->getOperand(i)->getType())
480  return false;
481 
482  return haveSameSpecialState(this, I, IgnoreAlignment);
483 }
484 
486  for (const Use &U : uses()) {
487  // PHI nodes uses values in the corresponding predecessor block. For other
488  // instructions, just check to see whether the parent of the use matches up.
489  const Instruction *I = cast<Instruction>(U.getUser());
490  const PHINode *PN = dyn_cast<PHINode>(I);
491  if (!PN) {
492  if (I->getParent() != BB)
493  return true;
494  continue;
495  }
496 
497  if (PN->getIncomingBlock(U) != BB)
498  return true;
499  }
500  return false;
501 }
502 
504  switch (getOpcode()) {
505  default: return false;
506  case Instruction::VAArg:
507  case Instruction::Load:
508  case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory
509  case Instruction::AtomicCmpXchg:
510  case Instruction::AtomicRMW:
511  case Instruction::CatchPad:
512  case Instruction::CatchRet:
513  return true;
514  case Instruction::Call:
515  return !cast<CallInst>(this)->doesNotAccessMemory();
516  case Instruction::Invoke:
517  return !cast<InvokeInst>(this)->doesNotAccessMemory();
518  case Instruction::Store:
519  return !cast<StoreInst>(this)->isUnordered();
520  }
521 }
522 
524  switch (getOpcode()) {
525  default: return false;
526  case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory
527  case Instruction::Store:
528  case Instruction::VAArg:
529  case Instruction::AtomicCmpXchg:
530  case Instruction::AtomicRMW:
531  case Instruction::CatchPad:
532  case Instruction::CatchRet:
533  return true;
534  case Instruction::Call:
535  return !cast<CallInst>(this)->onlyReadsMemory();
536  case Instruction::Invoke:
537  return !cast<InvokeInst>(this)->onlyReadsMemory();
538  case Instruction::Load:
539  return !cast<LoadInst>(this)->isUnordered();
540  }
541 }
542 
543 bool Instruction::isAtomic() const {
544  switch (getOpcode()) {
545  default:
546  return false;
547  case Instruction::AtomicCmpXchg:
548  case Instruction::AtomicRMW:
549  case Instruction::Fence:
550  return true;
551  case Instruction::Load:
552  return cast<LoadInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
553  case Instruction::Store:
554  return cast<StoreInst>(this)->getOrdering() != AtomicOrdering::NotAtomic;
555  }
556 }
557 
559  assert(isAtomic());
560  switch (getOpcode()) {
561  default:
562  return false;
563  case Instruction::AtomicCmpXchg:
564  case Instruction::AtomicRMW:
565  case Instruction::Load:
566  return true;
567  }
568 }
569 
571  assert(isAtomic());
572  switch (getOpcode()) {
573  default:
574  return false;
575  case Instruction::AtomicCmpXchg:
576  case Instruction::AtomicRMW:
577  case Instruction::Store:
578  return true;
579  }
580 }
581 
582 bool Instruction::mayThrow() const {
583  if (const CallInst *CI = dyn_cast<CallInst>(this))
584  return !CI->doesNotThrow();
585  if (const auto *CRI = dyn_cast<CleanupReturnInst>(this))
586  return CRI->unwindsToCaller();
587  if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(this))
588  return CatchSwitch->unwindsToCaller();
589  return isa<ResumeInst>(this);
590 }
591 
593  return (!isa<CallInst>(this) || !this->mayHaveSideEffects()) &&
594  !isa<TerminatorInst>(this);
595 }
596 
598  unsigned Opcode = getOpcode();
599  if (isAssociative(Opcode))
600  return true;
601 
602  switch (Opcode) {
603  case FMul:
604  case FAdd:
605  return cast<FPMathOperator>(this)->isFast();
606  default:
607  return false;
608  }
609 }
610 
611 Instruction *Instruction::cloneImpl() const {
612  llvm_unreachable("Subclass of Instruction failed to implement cloneImpl");
613 }
614 
616  MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
617  if (!ProfileData || ProfileData->getNumOperands() != 3 ||
618  !isa<MDString>(ProfileData->getOperand(0)))
619  return;
620 
621  MDString *MDName = cast<MDString>(ProfileData->getOperand(0));
622  if (MDName->getString() != "branch_weights")
623  return;
624 
625  // The first operand is the name. Fetch them backwards and build a new one.
626  Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
627  ProfileData->getOperand(1)};
629  MDNode::get(ProfileData->getContext(), Ops));
630 }
631 
633  ArrayRef<unsigned> WL) {
634  if (!SrcInst.hasMetadata())
635  return;
636 
637  DenseSet<unsigned> WLS;
638  for (unsigned M : WL)
639  WLS.insert(M);
640 
641  // Otherwise, enumerate and copy over metadata from the old instruction to the
642  // new one.
644  SrcInst.getAllMetadataOtherThanDebugLoc(TheMDs);
645  for (const auto &MD : TheMDs) {
646  if (WL.empty() || WLS.count(MD.first))
647  setMetadata(MD.first, MD.second);
648  }
649  if (WL.empty() || WLS.count(LLVMContext::MD_dbg))
650  setDebugLoc(SrcInst.getDebugLoc());
651 }
652 
654  Instruction *New = nullptr;
655  switch (getOpcode()) {
656  default:
657  llvm_unreachable("Unhandled Opcode.");
658 #define HANDLE_INST(num, opc, clas) \
659  case Instruction::opc: \
660  New = cast<clas>(this)->cloneImpl(); \
661  break;
662 #include "llvm/IR/Instruction.def"
663 #undef HANDLE_INST
664  }
665 
667  New->copyMetadata(*this);
668  return New;
669 }
670 
671 void Instruction::updateProfWeight(uint64_t S, uint64_t T) {
672  auto *ProfileData = getMetadata(LLVMContext::MD_prof);
673  if (ProfileData == nullptr)
674  return;
675 
676  auto *ProfDataName = dyn_cast<MDString>(ProfileData->getOperand(0));
677  if (!ProfDataName || (!ProfDataName->getString().equals("branch_weights") &&
678  !ProfDataName->getString().equals("VP")))
679  return;
680 
681  MDBuilder MDB(getContext());
683  Vals.push_back(ProfileData->getOperand(0));
684  APInt APS(128, S), APT(128, T);
685  if (ProfDataName->getString().equals("branch_weights"))
686  for (unsigned i = 1; i < ProfileData->getNumOperands(); i++) {
687  // Using APInt::div may be expensive, but most cases should fit 64 bits.
688  APInt Val(128,
689  mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i))
690  ->getValue()
691  .getZExtValue());
692  Val *= APS;
693  Vals.push_back(MDB.createConstant(
695  Val.udiv(APT).getLimitedValue())));
696  }
697  else if (ProfDataName->getString().equals("VP"))
698  for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
699  // The first value is the key of the value profile, which will not change.
700  Vals.push_back(ProfileData->getOperand(i));
701  // Using APInt::div may be expensive, but most cases should fit 64 bits.
702  APInt Val(128,
703  mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i + 1))
704  ->getValue()
705  .getZExtValue());
706  Val *= APS;
707  Vals.push_back(MDB.createConstant(
709  Val.udiv(APT).getLimitedValue())));
710  }
712 }
713 
715  assert((isa<CallInst>(this) || isa<InvokeInst>(this)) &&
716  "Can only set weights for call and invoke instrucitons");
717  SmallVector<uint32_t, 1> Weights;
718  Weights.push_back(W);
719  MDBuilder MDB(getContext());
721 }
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:218
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:67
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:843
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:360
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...
iterator erase(iterator where)
Definition: ilist.h:280
Compute iterated dominance frontiers using a linear time algorithm.
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:63
An instruction for ordering other memory operations.
Definition: Instructions.h:440
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:514
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:738
Metadata node.
Definition: Metadata.h:862
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1067
An instruction for reading from memory.
Definition: Instructions.h:164
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:677
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:214
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 it the function does no...
Definition: BasicBlock.cpp:116
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:185
Check for equivalence ignoring load/store alignment.
Definition: Instruction.h:580
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:583
LLVMContext & getContext() const
Definition: Metadata.h:922
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:195
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:306
Value * getOperand(unsigned i) const
Definition: User.h:154
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:301
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
StringRef getString() const
Definition: Metadata.cpp:456
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1164
#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:282
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:73
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
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:187
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:536
bool mayThrow() const
Return true if this instruction may throw an exception.
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
op_iterator op_end()
Definition: User.h:216
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:342
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:59
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:1214
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:317
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:85
Iterator for intrusive lists based on ilist_node.
unsigned getNumOperands() const
Definition: User.h:176
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:254
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
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:559
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:55
Class for arbitrary precision integers.
Definition: APInt.h:69
void push_back(pointer val)
Definition: ilist.h:326
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:63
pointer remove(iterator &IT)
Definition: ilist.h:264
List that automatically updates parent links and symbol tables.
iterator insert(iterator where, pointer New)
Definition: ilist.h:241
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:285
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:108
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:79
#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:91
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 nsw 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:90
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:86
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:602
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:1073
iterator insertAfter(iterator where, pointer New)
Definition: ilist.h:250
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.