LLVM  3.7.0
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/CallSite.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Instructions.h"
18 #include "llvm/IR/Module.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, 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 
44 
45 // Out of line virtual method, so the vtable, etc has a home.
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()->getModule();
63 }
64 
65 
67  getParent()->getInstList().remove(this);
68 }
69 
71  return getParent()->getInstList().erase(this);
72 }
73 
74 /// insertBefore - Insert an unlinked instructions into a basic block
75 /// immediately before the specified instruction.
77  InsertPos->getParent()->getInstList().insert(InsertPos, this);
78 }
79 
80 /// insertAfter - Insert an unlinked instructions into a basic block
81 /// immediately after the specified instruction.
83  InsertPos->getParent()->getInstList().insertAfter(InsertPos, this);
84 }
85 
86 /// moveBefore - Unlink this instruction from its current basic block and
87 /// insert it into the basic block that MovePos lives in, right before
88 /// MovePos.
90  MovePos->getParent()->getInstList().splice(MovePos,getParent()->getInstList(),
91  this);
92 }
93 
94 /// Set or clear the unsafe-algebra flag on this instruction, which must be an
95 /// operator which supports this flag. See LangRef.html for the meaning of this
96 /// flag.
98  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
99  cast<FPMathOperator>(this)->setHasUnsafeAlgebra(B);
100 }
101 
102 /// Set or clear the NoNaNs flag on this instruction, which must be an operator
103 /// which supports this flag. See LangRef.html for the meaning of this flag.
105  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
106  cast<FPMathOperator>(this)->setHasNoNaNs(B);
107 }
108 
109 /// Set or clear the no-infs flag on this instruction, which must be an operator
110 /// which supports this flag. See LangRef.html for the meaning of this flag.
112  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
113  cast<FPMathOperator>(this)->setHasNoInfs(B);
114 }
115 
116 /// Set or clear the no-signed-zeros flag on this instruction, which must be an
117 /// operator which supports this flag. See LangRef.html for the meaning of this
118 /// flag.
120  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
121  cast<FPMathOperator>(this)->setHasNoSignedZeros(B);
122 }
123 
124 /// Set or clear the allow-reciprocal flag on this instruction, which must be an
125 /// operator which supports this flag. See LangRef.html for the meaning of this
126 /// flag.
128  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
129  cast<FPMathOperator>(this)->setHasAllowReciprocal(B);
130 }
131 
132 /// Convenience function for setting all the fast-math flags on this
133 /// instruction, which must be an operator which supports these flags. See
134 /// LangRef.html for the meaning of these flats.
136  assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op");
137  cast<FPMathOperator>(this)->setFastMathFlags(FMF);
138 }
139 
141  assert(isa<FPMathOperator>(this) && "copying fast-math flag on invalid op");
142  cast<FPMathOperator>(this)->copyFastMathFlags(FMF);
143 }
144 
145 /// Determine whether the unsafe-algebra flag is set.
147  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
148  return cast<FPMathOperator>(this)->hasUnsafeAlgebra();
149 }
150 
151 /// Determine whether the no-NaNs flag is set.
153  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
154  return cast<FPMathOperator>(this)->hasNoNaNs();
155 }
156 
157 /// Determine whether the no-infs flag is set.
159  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
160  return cast<FPMathOperator>(this)->hasNoInfs();
161 }
162 
163 /// Determine whether the no-signed-zeros flag is set.
165  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
166  return cast<FPMathOperator>(this)->hasNoSignedZeros();
167 }
168 
169 /// Determine whether the allow-reciprocal flag is set.
171  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
172  return cast<FPMathOperator>(this)->hasAllowReciprocal();
173 }
174 
175 /// Convenience function for getting all the fast-math flags, which must be an
176 /// operator which supports these flags. See LangRef.html for the meaning of
177 /// these flags.
179  assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op");
180  return cast<FPMathOperator>(this)->getFastMathFlags();
181 }
182 
183 /// Copy I's fast-math flags
186 }
187 
188 
189 const char *Instruction::getOpcodeName(unsigned OpCode) {
190  switch (OpCode) {
191  // Terminators
192  case Ret: return "ret";
193  case Br: return "br";
194  case Switch: return "switch";
195  case IndirectBr: return "indirectbr";
196  case Invoke: return "invoke";
197  case Resume: return "resume";
198  case Unreachable: return "unreachable";
199 
200  // Standard binary operators...
201  case Add: return "add";
202  case FAdd: return "fadd";
203  case Sub: return "sub";
204  case FSub: return "fsub";
205  case Mul: return "mul";
206  case FMul: return "fmul";
207  case UDiv: return "udiv";
208  case SDiv: return "sdiv";
209  case FDiv: return "fdiv";
210  case URem: return "urem";
211  case SRem: return "srem";
212  case FRem: return "frem";
213 
214  // Logical operators...
215  case And: return "and";
216  case Or : return "or";
217  case Xor: return "xor";
218 
219  // Memory instructions...
220  case Alloca: return "alloca";
221  case Load: return "load";
222  case Store: return "store";
223  case AtomicCmpXchg: return "cmpxchg";
224  case AtomicRMW: return "atomicrmw";
225  case Fence: return "fence";
226  case GetElementPtr: return "getelementptr";
227 
228  // Convert instructions...
229  case Trunc: return "trunc";
230  case ZExt: return "zext";
231  case SExt: return "sext";
232  case FPTrunc: return "fptrunc";
233  case FPExt: return "fpext";
234  case FPToUI: return "fptoui";
235  case FPToSI: return "fptosi";
236  case UIToFP: return "uitofp";
237  case SIToFP: return "sitofp";
238  case IntToPtr: return "inttoptr";
239  case PtrToInt: return "ptrtoint";
240  case BitCast: return "bitcast";
241  case AddrSpaceCast: return "addrspacecast";
242 
243  // Other instructions...
244  case ICmp: return "icmp";
245  case FCmp: return "fcmp";
246  case PHI: return "phi";
247  case Select: return "select";
248  case Call: return "call";
249  case Shl: return "shl";
250  case LShr: return "lshr";
251  case AShr: return "ashr";
252  case VAArg: return "va_arg";
253  case ExtractElement: return "extractelement";
254  case InsertElement: return "insertelement";
255  case ShuffleVector: return "shufflevector";
256  case ExtractValue: return "extractvalue";
257  case InsertValue: return "insertvalue";
258  case LandingPad: return "landingpad";
259 
260  default: return "<Invalid operator> ";
261  }
262 }
263 
264 /// Return true if both instructions have the same special state
265 /// This must be kept in sync with lib/Transforms/IPO/MergeFunctions.cpp.
266 static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2,
267  bool IgnoreAlignment = false) {
268  assert(I1->getOpcode() == I2->getOpcode() &&
269  "Can not compare special state of different instructions");
270 
271  if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
272  return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
273  (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
274  IgnoreAlignment) &&
275  LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
276  LI->getSynchScope() == cast<LoadInst>(I2)->getSynchScope();
277  if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
278  return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
279  (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
280  IgnoreAlignment) &&
281  SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
282  SI->getSynchScope() == cast<StoreInst>(I2)->getSynchScope();
283  if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
284  return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
285  if (const CallInst *CI = dyn_cast<CallInst>(I1))
286  return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
287  CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
288  CI->getAttributes() == cast<CallInst>(I2)->getAttributes();
289  if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
290  return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
291  CI->getAttributes() ==
292  cast<InvokeInst>(I2)->getAttributes();
293  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
294  return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
295  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
296  return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
297  if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
298  return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
299  FI->getSynchScope() == cast<FenceInst>(I2)->getSynchScope();
300  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
301  return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
302  CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
303  CXI->getSuccessOrdering() ==
304  cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
305  CXI->getFailureOrdering() ==
306  cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
307  CXI->getSynchScope() == cast<AtomicCmpXchgInst>(I2)->getSynchScope();
308  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
309  return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
310  RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
311  RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
312  RMWI->getSynchScope() == cast<AtomicRMWInst>(I2)->getSynchScope();
313 
314  return true;
315 }
316 
317 /// isIdenticalTo - Return true if the specified instruction is exactly
318 /// identical to the current one. This means that all operands match and any
319 /// extra information (e.g. load is volatile) agree.
321  return isIdenticalToWhenDefined(I) &&
323 }
324 
325 /// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it
326 /// ignores the SubclassOptionalData flags, which specify conditions
327 /// under which the instruction's result is undefined.
329  if (getOpcode() != I->getOpcode() ||
330  getNumOperands() != I->getNumOperands() ||
331  getType() != I->getType())
332  return false;
333 
334  // If both instructions have no operands, they are identical.
335  if (getNumOperands() == 0 && I->getNumOperands() == 0)
336  return haveSameSpecialState(this, I);
337 
338  // We have two instructions of identical opcode and #operands. Check to see
339  // if all operands are the same.
340  if (!std::equal(op_begin(), op_end(), I->op_begin()))
341  return false;
342 
343  if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
344  const PHINode *otherPHI = cast<PHINode>(I);
345  return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
346  otherPHI->block_begin());
347  }
348 
349  return haveSameSpecialState(this, I);
350 }
351 
352 // isSameOperationAs
353 // This should be kept in sync with isEquivalentOperation in
354 // lib/Transforms/IPO/MergeFunctions.cpp.
356  unsigned flags) const {
357  bool IgnoreAlignment = flags & CompareIgnoringAlignment;
358  bool UseScalarTypes = flags & CompareUsingScalarTypes;
359 
360  if (getOpcode() != I->getOpcode() ||
361  getNumOperands() != I->getNumOperands() ||
362  (UseScalarTypes ?
363  getType()->getScalarType() != I->getType()->getScalarType() :
364  getType() != I->getType()))
365  return false;
366 
367  // We have two instructions of identical opcode and #operands. Check to see
368  // if all operands are the same type
369  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
370  if (UseScalarTypes ?
371  getOperand(i)->getType()->getScalarType() !=
372  I->getOperand(i)->getType()->getScalarType() :
373  getOperand(i)->getType() != I->getOperand(i)->getType())
374  return false;
375 
376  return haveSameSpecialState(this, I, IgnoreAlignment);
377 }
378 
379 /// isUsedOutsideOfBlock - Return true if there are any uses of I outside of the
380 /// specified block. Note that PHI nodes are considered to evaluate their
381 /// operands in the corresponding predecessor block.
383  for (const Use &U : uses()) {
384  // PHI nodes uses values in the corresponding predecessor block. For other
385  // instructions, just check to see whether the parent of the use matches up.
386  const Instruction *I = cast<Instruction>(U.getUser());
387  const PHINode *PN = dyn_cast<PHINode>(I);
388  if (!PN) {
389  if (I->getParent() != BB)
390  return true;
391  continue;
392  }
393 
394  if (PN->getIncomingBlock(U) != BB)
395  return true;
396  }
397  return false;
398 }
399 
400 /// mayReadFromMemory - Return true if this instruction may read memory.
401 ///
403  switch (getOpcode()) {
404  default: return false;
405  case Instruction::VAArg:
406  case Instruction::Load:
407  case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory
408  case Instruction::AtomicCmpXchg:
409  case Instruction::AtomicRMW:
410  return true;
411  case Instruction::Call:
412  return !cast<CallInst>(this)->doesNotAccessMemory();
413  case Instruction::Invoke:
414  return !cast<InvokeInst>(this)->doesNotAccessMemory();
415  case Instruction::Store:
416  return !cast<StoreInst>(this)->isUnordered();
417  }
418 }
419 
420 /// mayWriteToMemory - Return true if this instruction may modify memory.
421 ///
423  switch (getOpcode()) {
424  default: return false;
425  case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory
426  case Instruction::Store:
427  case Instruction::VAArg:
428  case Instruction::AtomicCmpXchg:
429  case Instruction::AtomicRMW:
430  return true;
431  case Instruction::Call:
432  return !cast<CallInst>(this)->onlyReadsMemory();
433  case Instruction::Invoke:
434  return !cast<InvokeInst>(this)->onlyReadsMemory();
435  case Instruction::Load:
436  return !cast<LoadInst>(this)->isUnordered();
437  }
438 }
439 
440 bool Instruction::isAtomic() const {
441  switch (getOpcode()) {
442  default:
443  return false;
444  case Instruction::AtomicCmpXchg:
445  case Instruction::AtomicRMW:
446  case Instruction::Fence:
447  return true;
448  case Instruction::Load:
449  return cast<LoadInst>(this)->getOrdering() != NotAtomic;
450  case Instruction::Store:
451  return cast<StoreInst>(this)->getOrdering() != NotAtomic;
452  }
453 }
454 
455 bool Instruction::mayThrow() const {
456  if (const CallInst *CI = dyn_cast<CallInst>(this))
457  return !CI->doesNotThrow();
458  return isa<ResumeInst>(this);
459 }
460 
462  if (const CallInst *CI = dyn_cast<CallInst>(this))
463  return !CI->doesNotReturn();
464  return true;
465 }
466 
467 /// isAssociative - Return true if the instruction is associative:
468 ///
469 /// Associative operators satisfy: x op (y op z) === (x op y) op z
470 ///
471 /// In LLVM, the Add, Mul, And, Or, and Xor operators are associative.
472 ///
473 bool Instruction::isAssociative(unsigned Opcode) {
474  return Opcode == And || Opcode == Or || Opcode == Xor ||
475  Opcode == Add || Opcode == Mul;
476 }
477 
479  unsigned Opcode = getOpcode();
480  if (isAssociative(Opcode))
481  return true;
482 
483  switch (Opcode) {
484  case FMul:
485  case FAdd:
486  return cast<FPMathOperator>(this)->hasUnsafeAlgebra();
487  default:
488  return false;
489  }
490 }
491 
492 /// isCommutative - Return true if the instruction is commutative:
493 ///
494 /// Commutative operators satisfy: (x op y) === (y op x)
495 ///
496 /// In LLVM, these are the associative operators, plus SetEQ and SetNE, when
497 /// applied to any type.
498 ///
500  switch (op) {
501  case Add:
502  case FAdd:
503  case Mul:
504  case FMul:
505  case And:
506  case Or:
507  case Xor:
508  return true;
509  default:
510  return false;
511  }
512 }
513 
514 /// isIdempotent - Return true if the instruction is idempotent:
515 ///
516 /// Idempotent operators satisfy: x op x === x
517 ///
518 /// In LLVM, the And and Or operators are idempotent.
519 ///
520 bool Instruction::isIdempotent(unsigned Opcode) {
521  return Opcode == And || Opcode == Or;
522 }
523 
524 /// isNilpotent - Return true if the instruction is nilpotent:
525 ///
526 /// Nilpotent operators satisfy: x op x === Id,
527 ///
528 /// where Id is the identity for the operator, i.e. a constant such that
529 /// x op Id === x and Id op x === x for all x.
530 ///
531 /// In LLVM, the Xor operator is nilpotent.
532 ///
533 bool Instruction::isNilpotent(unsigned Opcode) {
534  return Opcode == Xor;
535 }
536 
537 Instruction *Instruction::cloneImpl() const {
538  llvm_unreachable("Subclass of Instruction failed to implement cloneImpl");
539 }
540 
542  Instruction *New = nullptr;
543  switch (getOpcode()) {
544  default:
545  llvm_unreachable("Unhandled Opcode.");
546 #define HANDLE_INST(num, opc, clas) \
547  case Instruction::opc: \
548  New = cast<clas>(this)->cloneImpl(); \
549  break;
550 #include "llvm/IR/Instruction.def"
551 #undef HANDLE_INST
552  }
553 
555  if (!hasMetadata())
556  return New;
557 
558  // Otherwise, enumerate and copy over metadata from the old instruction to the
559  // new one.
562  for (const auto &MD : TheMDs)
563  New->setMetadata(MD.first, MD.second);
564 
565  New->setDebugLoc(getDebugLoc());
566  return New;
567 }
bool isNilpotent() const
isNilpotent - Return true if the instruction is nilpotent:
Definition: Instruction.h:348
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
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:679
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:283
ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
FenceInst - an instruction for ordering other memory operations.
Definition: Instructions.h:445
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
unsigned getNumOperands() const
Definition: User.h:138
CallInst - This class represents a function call, abstracting a target machine'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 isUsedOutsideOfBlock(const BasicBlock *BB) const
isUsedOutsideOfBlock - Return true if there are any uses of this instruction in blocks other than the...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
Definition: Instructions.h:674
#define op(i)
op_iterator op_begin()
Definition: User.h:183
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
bool mayReturn() const
mayReturn - Return true if this is a function that may return.
void push_back(NodeTy *val)
Definition: ilist.h:554
bool isIdenticalTo(const Instruction *I) const
isIdenticalTo - Return true if the specified instruction is exactly identical to the current one...
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
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, bool IgnoreAlignment=false)
Return true if both instructions have the same special state This must be kept in sync with lib/Trans...
bool hasAllowReciprocal() const
Determine whether the allow-reciprocal flag is set.
~Instruction() override
Definition: Instruction.cpp:46
Check for equivalence ignoring load/store alignment.
Definition: Instruction.h:412
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
Instruction * clone() const
clone() - Create a copy of 'this' instruction that is identical in all ways except the following: ...
block_iterator block_begin()
Check for equivalence treating a type and a vector of that type as equivalent.
Definition: Instruction.h:415
bool mayReadFromMemory() const
mayReadFromMemory - Return true if this instruction may read memory.
bool isAssociative() const
isAssociative - Return true if the instruction is associative:
void setHasUnsafeAlgebra(bool B)
Set or clear the unsafe-algebra flag on this instruction, which must be an operator which supports th...
Definition: Instruction.cpp:97
bool hasUnsafeAlgebra() const
Determine whether the unsafe-algebra flag is set.
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
const char * getOpcodeName() const
Definition: Instruction.h:114
bool isAtomic() const
isAtomic - Return true if this instruction has an AtomicOrdering of unordered or higher.
#define P(N)
void setDebugLoc(DebugLoc Loc)
setDebugLoc - Set the debug location information for this instruction.
Definition: Instruction.h:227
bool isIdenticalToWhenDefined(const Instruction *I) const
isIdenticalToWhenDefined - This is like isIdenticalTo, except that it ignores the SubclassOptionalDat...
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction...
Definition: Instruction.cpp:76
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
getAllMetadataOtherThanDebugLoc - This does the same thing as getAllMetadata, except that it filters ...
Definition: Instruction.h:190
This file contains the declarations for the subclasses of Constant, which represent the different fla...
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1900
bool hasMetadata() const
hasMetadata() - Return true if this instruction has any metadata attached to it.
Definition: Instruction.h:157
iterator insertAfter(iterator where, NodeTy *New)
Definition: ilist.h:428
const DebugLoc & getDebugLoc() const
getDebugLoc - Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:230
op_iterator op_end()
Definition: User.h:185
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
iterator insert(iterator where, NodeTy *New)
Definition: ilist.h:412
Value * getOperand(unsigned i) const
Definition: User.h:118
bool isCommutative() const
isCommutative - Return true if the instruction is commutative:
Definition: Instruction.h:327
void setHasNoInfs(bool B)
Set or clear the no-infs flag on this instruction, which must be an operator which supports this flag...
iplist - The subset of list functionality that can safely be used on nodes of polymorphic types...
Definition: ilist.h:49
iterator erase(iterator where)
Definition: ilist.h:465
void setMetadata(unsigned KindID, MDNode *Node)
setMetadata - Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1083
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:84
bool mayWriteToMemory() const
mayWriteToMemory - Return true if this instruction may modify memory.
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
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
static bool isWeak(const MCSymbolELF &Sym)
LLVM_ATTRIBUTE_UNUSED_RESULT 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:285
const Type * getScalarType() const LLVM_READONLY
getScalarType - If this is a vector type, return the element type, otherwise return 'this'...
Definition: Type.cpp:51
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1890
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing basic block, but does not delete it...
Definition: Instruction.cpp:66
bool mayThrow() const
mayThrow - Return true if this instruction may throw an exception.
bool isIdempotent() const
isIdempotent - Return true if the instruction is idempotent:
Definition: Instruction.h:336
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:82
#define I(x, y, z)
Definition: MD5.cpp:54
bool hasNoInfs() const
Determine whether the no-infs flag is set.
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
AttributeSet getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
LLVM Value Representation.
Definition: Value.h:69
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
void moveBefore(Instruction *MovePos)
moveBefore - Unlink this instruction from its current basic block and insert it into the basic block ...
Definition: Instruction.cpp:89
InvokeInst - Invoke instruction.
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:164
bool isSameOperationAs(const Instruction *I, unsigned flags=0) const
This function determines if the specified instruction executes the same operation as the current one...
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...
NodeTy * remove(iterator &IT)
Definition: ilist.h:435
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:72
InsertValueInst - This instruction inserts a struct field of array element value into an aggregate va...