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