LLVM  3.7.0
Instructions.cpp
Go to the documentation of this file.
1 //===-- Instructions.cpp - Implement the LLVM instructions ----------------===//
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 all of the non-inline methods for the LLVM instruction
11 // classes.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/IR/Instructions.h"
16 #include "LLVMContextImpl.h"
17 #include "llvm/IR/CallSite.h"
18 #include "llvm/IR/ConstantRange.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/DataLayout.h"
21 #include "llvm/IR/DerivedTypes.h"
22 #include "llvm/IR/Function.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Operator.h"
27 using namespace llvm;
28 
29 //===----------------------------------------------------------------------===//
30 // CallSite Class
31 //===----------------------------------------------------------------------===//
32 
33 User::op_iterator CallSite::getCallee() const {
35  return isCall()
36  ? cast<CallInst>(II)->op_end() - 1 // Skip Callee
37  : cast<InvokeInst>(II)->op_end() - 3; // Skip BB, BB, Callee
38 }
39 
40 //===----------------------------------------------------------------------===//
41 // TerminatorInst Class
42 //===----------------------------------------------------------------------===//
43 
44 // Out of line virtual method, so the vtable, etc has a home.
46 }
47 
48 //===----------------------------------------------------------------------===//
49 // UnaryInstruction Class
50 //===----------------------------------------------------------------------===//
51 
52 // Out of line virtual method, so the vtable, etc has a home.
54 }
55 
56 //===----------------------------------------------------------------------===//
57 // SelectInst Class
58 //===----------------------------------------------------------------------===//
59 
60 /// areInvalidOperands - Return a string if the specified operands are invalid
61 /// for a select operation, otherwise return null.
62 const char *SelectInst::areInvalidOperands(Value *Op0, Value *Op1, Value *Op2) {
63  if (Op1->getType() != Op2->getType())
64  return "both values to select must have same type";
65 
66  if (VectorType *VT = dyn_cast<VectorType>(Op0->getType())) {
67  // Vector select.
68  if (VT->getElementType() != Type::getInt1Ty(Op0->getContext()))
69  return "vector select condition element type must be i1";
70  VectorType *ET = dyn_cast<VectorType>(Op1->getType());
71  if (!ET)
72  return "selected values for vector select must be vectors";
73  if (ET->getNumElements() != VT->getNumElements())
74  return "vector select requires selected vectors to have "
75  "the same vector length as select condition";
76  } else if (Op0->getType() != Type::getInt1Ty(Op0->getContext())) {
77  return "select condition must be i1 or <n x i1>";
78  }
79  return nullptr;
80 }
81 
82 
83 //===----------------------------------------------------------------------===//
84 // PHINode Class
85 //===----------------------------------------------------------------------===//
86 
87 PHINode::PHINode(const PHINode &PN)
88  : Instruction(PN.getType(), Instruction::PHI, nullptr, PN.getNumOperands()),
89  ReservedSpace(PN.getNumOperands()) {
91  std::copy(PN.op_begin(), PN.op_end(), op_begin());
92  std::copy(PN.block_begin(), PN.block_end(), block_begin());
94 }
95 
96 // removeIncomingValue - Remove an incoming value. This is useful if a
97 // predecessor basic block is deleted.
98 Value *PHINode::removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty) {
99  Value *Removed = getIncomingValue(Idx);
100 
101  // Move everything after this operand down.
102  //
103  // FIXME: we could just swap with the end of the list, then erase. However,
104  // clients might not expect this to happen. The code as it is thrashes the
105  // use/def lists, which is kinda lame.
106  std::copy(op_begin() + Idx + 1, op_end(), op_begin() + Idx);
107  std::copy(block_begin() + Idx + 1, block_end(), block_begin() + Idx);
108 
109  // Nuke the last value.
110  Op<-1>().set(nullptr);
112 
113  // If the PHI node is dead, because it has zero entries, nuke it now.
114  if (getNumOperands() == 0 && DeletePHIIfEmpty) {
115  // If anyone is using this PHI, make them use a dummy value instead...
117  eraseFromParent();
118  }
119  return Removed;
120 }
121 
122 /// growOperands - grow operands - This grows the operand list in response
123 /// to a push_back style of operation. This grows the number of ops by 1.5
124 /// times.
125 ///
126 void PHINode::growOperands() {
127  unsigned e = getNumOperands();
128  unsigned NumOps = e + e / 2;
129  if (NumOps < 2) NumOps = 2; // 2 op PHI nodes are VERY common.
130 
131  ReservedSpace = NumOps;
132  growHungoffUses(ReservedSpace, /* IsPhi */ true);
133 }
134 
135 /// hasConstantValue - If the specified PHI node always merges together the same
136 /// value, return the value, otherwise return null.
138  // Exploit the fact that phi nodes always have at least one entry.
139  Value *ConstantValue = getIncomingValue(0);
140  for (unsigned i = 1, e = getNumIncomingValues(); i != e; ++i)
141  if (getIncomingValue(i) != ConstantValue && getIncomingValue(i) != this) {
142  if (ConstantValue != this)
143  return nullptr; // Incoming values not all the same.
144  // The case where the first value is this PHI.
145  ConstantValue = getIncomingValue(i);
146  }
147  if (ConstantValue == this)
148  return UndefValue::get(getType());
149  return ConstantValue;
150 }
151 
152 //===----------------------------------------------------------------------===//
153 // LandingPadInst Implementation
154 //===----------------------------------------------------------------------===//
155 
156 LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
157  const Twine &NameStr, Instruction *InsertBefore)
158  : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
159  init(NumReservedValues, NameStr);
160 }
161 
162 LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
163  const Twine &NameStr, BasicBlock *InsertAtEnd)
164  : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) {
165  init(NumReservedValues, NameStr);
166 }
167 
168 LandingPadInst::LandingPadInst(const LandingPadInst &LP)
169  : Instruction(LP.getType(), Instruction::LandingPad, nullptr,
170  LP.getNumOperands()),
171  ReservedSpace(LP.getNumOperands()) {
173  Use *OL = getOperandList();
174  const Use *InOL = LP.getOperandList();
175  for (unsigned I = 0, E = ReservedSpace; I != E; ++I)
176  OL[I] = InOL[I];
177 
178  setCleanup(LP.isCleanup());
179 }
180 
181 LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses,
182  const Twine &NameStr,
183  Instruction *InsertBefore) {
184  return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertBefore);
185 }
186 
187 LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses,
188  const Twine &NameStr,
189  BasicBlock *InsertAtEnd) {
190  return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertAtEnd);
191 }
192 
193 void LandingPadInst::init(unsigned NumReservedValues, const Twine &NameStr) {
194  ReservedSpace = NumReservedValues;
196  allocHungoffUses(ReservedSpace);
197  setName(NameStr);
198  setCleanup(false);
199 }
200 
201 /// growOperands - grow operands - This grows the operand list in response to a
202 /// push_back style of operation. This grows the number of ops by 2 times.
203 void LandingPadInst::growOperands(unsigned Size) {
204  unsigned e = getNumOperands();
205  if (ReservedSpace >= e + Size) return;
206  ReservedSpace = (std::max(e, 1U) + Size / 2) * 2;
207  growHungoffUses(ReservedSpace);
208 }
209 
211  unsigned OpNo = getNumOperands();
212  growOperands(1);
213  assert(OpNo < ReservedSpace && "Growing didn't work!");
215  getOperandList()[OpNo] = Val;
216 }
217 
218 //===----------------------------------------------------------------------===//
219 // CallInst Implementation
220 //===----------------------------------------------------------------------===//
221 
223 }
224 
225 void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
226  const Twine &NameStr) {
227  this->FTy = FTy;
228  assert(getNumOperands() == Args.size() + 1 && "NumOperands not set up?");
229  Op<-1>() = Func;
230 
231 #ifndef NDEBUG
232  assert((Args.size() == FTy->getNumParams() ||
233  (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
234  "Calling a function with bad signature!");
235 
236  for (unsigned i = 0; i != Args.size(); ++i)
237  assert((i >= FTy->getNumParams() ||
238  FTy->getParamType(i) == Args[i]->getType()) &&
239  "Calling a function with a bad signature!");
240 #endif
241 
242  std::copy(Args.begin(), Args.end(), op_begin());
243  setName(NameStr);
244 }
245 
246 void CallInst::init(Value *Func, const Twine &NameStr) {
247  FTy =
248  cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
249  assert(getNumOperands() == 1 && "NumOperands not set up?");
250  Op<-1>() = Func;
251 
252  assert(FTy->getNumParams() == 0 && "Calling a function with bad signature");
253 
254  setName(NameStr);
255 }
256 
257 CallInst::CallInst(Value *Func, const Twine &Name,
258  Instruction *InsertBefore)
260  ->getElementType())->getReturnType(),
261  Instruction::Call,
262  OperandTraits<CallInst>::op_end(this) - 1,
263  1, InsertBefore) {
264  init(Func, Name);
265 }
266 
267 CallInst::CallInst(Value *Func, const Twine &Name,
268  BasicBlock *InsertAtEnd)
270  ->getElementType())->getReturnType(),
271  Instruction::Call,
272  OperandTraits<CallInst>::op_end(this) - 1,
273  1, InsertAtEnd) {
274  init(Func, Name);
275 }
276 
277 CallInst::CallInst(const CallInst &CI)
279  OperandTraits<CallInst>::op_end(this) - CI.getNumOperands(),
280  CI.getNumOperands()),
281  AttributeList(CI.AttributeList), FTy(CI.FTy) {
284 
285  std::copy(CI.op_begin(), CI.op_end(), op_begin());
287 }
288 
290  AttributeSet PAL = getAttributes();
291  PAL = PAL.addAttribute(getContext(), i, attr);
292  setAttributes(PAL);
293 }
294 
296  AttributeSet PAL = getAttributes();
297  PAL = PAL.addAttribute(getContext(), i, Kind, Value);
298  setAttributes(PAL);
299 }
300 
301 void CallInst::removeAttribute(unsigned i, Attribute attr) {
302  AttributeSet PAL = getAttributes();
303  AttrBuilder B(attr);
304  LLVMContext &Context = getContext();
305  PAL = PAL.removeAttributes(Context, i,
306  AttributeSet::get(Context, i, B));
307  setAttributes(PAL);
308 }
309 
310 void CallInst::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
311  AttributeSet PAL = getAttributes();
312  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
313  setAttributes(PAL);
314 }
315 
316 void CallInst::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
317  AttributeSet PAL = getAttributes();
318  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
319  setAttributes(PAL);
320 }
321 
323  if (AttributeList.hasAttribute(i, A))
324  return true;
325  if (const Function *F = getCalledFunction())
326  return F->getAttributes().hasAttribute(i, A);
327  return false;
328 }
329 
330 /// IsConstantOne - Return true only if val is constant int 1
331 static bool IsConstantOne(Value *val) {
332  assert(val && "IsConstantOne does not work with nullptr val");
333  const ConstantInt *CVal = dyn_cast<ConstantInt>(val);
334  return CVal && CVal->isOne();
335 }
336 
337 static Instruction *createMalloc(Instruction *InsertBefore,
338  BasicBlock *InsertAtEnd, Type *IntPtrTy,
339  Type *AllocTy, Value *AllocSize,
340  Value *ArraySize, Function *MallocF,
341  const Twine &Name) {
342  assert(((!InsertBefore && InsertAtEnd) || (InsertBefore && !InsertAtEnd)) &&
343  "createMalloc needs either InsertBefore or InsertAtEnd");
344 
345  // malloc(type) becomes:
346  // bitcast (i8* malloc(typeSize)) to type*
347  // malloc(type, arraySize) becomes:
348  // bitcast (i8 *malloc(typeSize*arraySize)) to type*
349  if (!ArraySize)
350  ArraySize = ConstantInt::get(IntPtrTy, 1);
351  else if (ArraySize->getType() != IntPtrTy) {
352  if (InsertBefore)
353  ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false,
354  "", InsertBefore);
355  else
356  ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false,
357  "", InsertAtEnd);
358  }
359 
360  if (!IsConstantOne(ArraySize)) {
361  if (IsConstantOne(AllocSize)) {
362  AllocSize = ArraySize; // Operand * 1 = Operand
363  } else if (Constant *CO = dyn_cast<Constant>(ArraySize)) {
364  Constant *Scale = ConstantExpr::getIntegerCast(CO, IntPtrTy,
365  false /*ZExt*/);
366  // Malloc arg is constant product of type size and array size
367  AllocSize = ConstantExpr::getMul(Scale, cast<Constant>(AllocSize));
368  } else {
369  // Multiply type size by the array size...
370  if (InsertBefore)
371  AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize,
372  "mallocsize", InsertBefore);
373  else
374  AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize,
375  "mallocsize", InsertAtEnd);
376  }
377  }
378 
379  assert(AllocSize->getType() == IntPtrTy && "malloc arg is wrong size");
380  // Create the call to Malloc.
381  BasicBlock* BB = InsertBefore ? InsertBefore->getParent() : InsertAtEnd;
382  Module* M = BB->getParent()->getParent();
383  Type *BPTy = Type::getInt8PtrTy(BB->getContext());
384  Value *MallocFunc = MallocF;
385  if (!MallocFunc)
386  // prototype malloc as "void *malloc(size_t)"
387  MallocFunc = M->getOrInsertFunction("malloc", BPTy, IntPtrTy, nullptr);
388  PointerType *AllocPtrType = PointerType::getUnqual(AllocTy);
389  CallInst *MCall = nullptr;
390  Instruction *Result = nullptr;
391  if (InsertBefore) {
392  MCall = CallInst::Create(MallocFunc, AllocSize, "malloccall", InsertBefore);
393  Result = MCall;
394  if (Result->getType() != AllocPtrType)
395  // Create a cast instruction to convert to the right type...
396  Result = new BitCastInst(MCall, AllocPtrType, Name, InsertBefore);
397  } else {
398  MCall = CallInst::Create(MallocFunc, AllocSize, "malloccall");
399  Result = MCall;
400  if (Result->getType() != AllocPtrType) {
401  InsertAtEnd->getInstList().push_back(MCall);
402  // Create a cast instruction to convert to the right type...
403  Result = new BitCastInst(MCall, AllocPtrType, Name);
404  }
405  }
406  MCall->setTailCall();
407  if (Function *F = dyn_cast<Function>(MallocFunc)) {
408  MCall->setCallingConv(F->getCallingConv());
409  if (!F->doesNotAlias(0)) F->setDoesNotAlias(0);
410  }
411  assert(!MCall->getType()->isVoidTy() && "Malloc has void return type");
412 
413  return Result;
414 }
415 
416 /// CreateMalloc - Generate the IR for a call to malloc:
417 /// 1. Compute the malloc call's argument as the specified type's size,
418 /// possibly multiplied by the array size if the array size is not
419 /// constant 1.
420 /// 2. Call malloc with that argument.
421 /// 3. Bitcast the result of the malloc call to the specified type.
423  Type *IntPtrTy, Type *AllocTy,
424  Value *AllocSize, Value *ArraySize,
425  Function * MallocF,
426  const Twine &Name) {
427  return createMalloc(InsertBefore, nullptr, IntPtrTy, AllocTy, AllocSize,
428  ArraySize, MallocF, Name);
429 }
430 
431 /// CreateMalloc - Generate the IR for a call to malloc:
432 /// 1. Compute the malloc call's argument as the specified type's size,
433 /// possibly multiplied by the array size if the array size is not
434 /// constant 1.
435 /// 2. Call malloc with that argument.
436 /// 3. Bitcast the result of the malloc call to the specified type.
437 /// Note: This function does not add the bitcast to the basic block, that is the
438 /// responsibility of the caller.
440  Type *IntPtrTy, Type *AllocTy,
441  Value *AllocSize, Value *ArraySize,
442  Function *MallocF, const Twine &Name) {
443  return createMalloc(nullptr, InsertAtEnd, IntPtrTy, AllocTy, AllocSize,
444  ArraySize, MallocF, Name);
445 }
446 
448  BasicBlock *InsertAtEnd) {
449  assert(((!InsertBefore && InsertAtEnd) || (InsertBefore && !InsertAtEnd)) &&
450  "createFree needs either InsertBefore or InsertAtEnd");
451  assert(Source->getType()->isPointerTy() &&
452  "Can not free something of nonpointer type!");
453 
454  BasicBlock* BB = InsertBefore ? InsertBefore->getParent() : InsertAtEnd;
455  Module* M = BB->getParent()->getParent();
456 
457  Type *VoidTy = Type::getVoidTy(M->getContext());
458  Type *IntPtrTy = Type::getInt8PtrTy(M->getContext());
459  // prototype free as "void free(void*)"
460  Value *FreeFunc = M->getOrInsertFunction("free", VoidTy, IntPtrTy, nullptr);
461  CallInst* Result = nullptr;
462  Value *PtrCast = Source;
463  if (InsertBefore) {
464  if (Source->getType() != IntPtrTy)
465  PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertBefore);
466  Result = CallInst::Create(FreeFunc, PtrCast, "", InsertBefore);
467  } else {
468  if (Source->getType() != IntPtrTy)
469  PtrCast = new BitCastInst(Source, IntPtrTy, "", InsertAtEnd);
470  Result = CallInst::Create(FreeFunc, PtrCast, "");
471  }
472  Result->setTailCall();
473  if (Function *F = dyn_cast<Function>(FreeFunc))
474  Result->setCallingConv(F->getCallingConv());
475 
476  return Result;
477 }
478 
479 /// CreateFree - Generate the IR for a call to the builtin free function.
481  return createFree(Source, InsertBefore, nullptr);
482 }
483 
484 /// CreateFree - Generate the IR for a call to the builtin free function.
485 /// Note: This function does not add the call to the basic block, that is the
486 /// responsibility of the caller.
488  Instruction* FreeCall = createFree(Source, nullptr, InsertAtEnd);
489  assert(FreeCall && "CreateFree did not create a CallInst");
490  return FreeCall;
491 }
492 
493 //===----------------------------------------------------------------------===//
494 // InvokeInst Implementation
495 //===----------------------------------------------------------------------===//
496 
497 void InvokeInst::init(FunctionType *FTy, Value *Fn, BasicBlock *IfNormal,
498  BasicBlock *IfException, ArrayRef<Value *> Args,
499  const Twine &NameStr) {
500  this->FTy = FTy;
501 
502  assert(getNumOperands() == 3 + Args.size() && "NumOperands not set up?");
503  Op<-3>() = Fn;
504  Op<-2>() = IfNormal;
505  Op<-1>() = IfException;
506 
507 #ifndef NDEBUG
508  assert(((Args.size() == FTy->getNumParams()) ||
509  (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
510  "Invoking a function with bad signature");
511 
512  for (unsigned i = 0, e = Args.size(); i != e; i++)
513  assert((i >= FTy->getNumParams() ||
514  FTy->getParamType(i) == Args[i]->getType()) &&
515  "Invoking a function with a bad signature!");
516 #endif
517 
518  std::copy(Args.begin(), Args.end(), op_begin());
519  setName(NameStr);
520 }
521 
522 InvokeInst::InvokeInst(const InvokeInst &II)
523  : TerminatorInst(II.getType(), Instruction::Invoke,
524  OperandTraits<InvokeInst>::op_end(this) -
525  II.getNumOperands(),
526  II.getNumOperands()),
527  AttributeList(II.AttributeList), FTy(II.FTy) {
529  std::copy(II.op_begin(), II.op_end(), op_begin());
531 }
532 
533 BasicBlock *InvokeInst::getSuccessorV(unsigned idx) const {
534  return getSuccessor(idx);
535 }
536 unsigned InvokeInst::getNumSuccessorsV() const {
537  return getNumSuccessors();
538 }
539 void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) {
540  return setSuccessor(idx, B);
541 }
542 
543 bool InvokeInst::hasFnAttrImpl(Attribute::AttrKind A) const {
544  if (AttributeList.hasAttribute(AttributeSet::FunctionIndex, A))
545  return true;
546  if (const Function *F = getCalledFunction())
547  return F->getAttributes().hasAttribute(AttributeSet::FunctionIndex, A);
548  return false;
549 }
550 
552  if (AttributeList.hasAttribute(i, A))
553  return true;
554  if (const Function *F = getCalledFunction())
555  return F->getAttributes().hasAttribute(i, A);
556  return false;
557 }
558 
560  AttributeSet PAL = getAttributes();
561  PAL = PAL.addAttribute(getContext(), i, attr);
562  setAttributes(PAL);
563 }
564 
565 void InvokeInst::removeAttribute(unsigned i, Attribute attr) {
566  AttributeSet PAL = getAttributes();
567  AttrBuilder B(attr);
568  PAL = PAL.removeAttributes(getContext(), i,
569  AttributeSet::get(getContext(), i, B));
570  setAttributes(PAL);
571 }
572 
573 void InvokeInst::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
574  AttributeSet PAL = getAttributes();
575  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
576  setAttributes(PAL);
577 }
578 
579 void InvokeInst::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
580  AttributeSet PAL = getAttributes();
581  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
582  setAttributes(PAL);
583 }
584 
586  return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI());
587 }
588 
589 //===----------------------------------------------------------------------===//
590 // ReturnInst Implementation
591 //===----------------------------------------------------------------------===//
592 
593 ReturnInst::ReturnInst(const ReturnInst &RI)
594  : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Ret,
595  OperandTraits<ReturnInst>::op_end(this) -
596  RI.getNumOperands(),
597  RI.getNumOperands()) {
598  if (RI.getNumOperands())
599  Op<0>() = RI.Op<0>();
601 }
602 
603 ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore)
604  : TerminatorInst(Type::getVoidTy(C), Instruction::Ret,
605  OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
606  InsertBefore) {
607  if (retVal)
608  Op<0>() = retVal;
609 }
610 ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd)
611  : TerminatorInst(Type::getVoidTy(C), Instruction::Ret,
612  OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
613  InsertAtEnd) {
614  if (retVal)
615  Op<0>() = retVal;
616 }
617 ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd)
618  : TerminatorInst(Type::getVoidTy(Context), Instruction::Ret,
619  OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {
620 }
621 
622 unsigned ReturnInst::getNumSuccessorsV() const {
623  return getNumSuccessors();
624 }
625 
626 /// Out-of-line ReturnInst method, put here so the C++ compiler can choose to
627 /// emit the vtable for the class in this translation unit.
628 void ReturnInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) {
629  llvm_unreachable("ReturnInst has no successors!");
630 }
631 
632 BasicBlock *ReturnInst::getSuccessorV(unsigned idx) const {
633  llvm_unreachable("ReturnInst has no successors!");
634 }
635 
637 }
638 
639 //===----------------------------------------------------------------------===//
640 // ResumeInst Implementation
641 //===----------------------------------------------------------------------===//
642 
643 ResumeInst::ResumeInst(const ResumeInst &RI)
644  : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Resume,
645  OperandTraits<ResumeInst>::op_begin(this), 1) {
646  Op<0>() = RI.Op<0>();
647 }
648 
649 ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore)
650  : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
651  OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
652  Op<0>() = Exn;
653 }
654 
655 ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd)
656  : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
657  OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) {
658  Op<0>() = Exn;
659 }
660 
661 unsigned ResumeInst::getNumSuccessorsV() const {
662  return getNumSuccessors();
663 }
664 
665 void ResumeInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) {
666  llvm_unreachable("ResumeInst has no successors!");
667 }
668 
669 BasicBlock *ResumeInst::getSuccessorV(unsigned idx) const {
670  llvm_unreachable("ResumeInst has no successors!");
671 }
672 
673 //===----------------------------------------------------------------------===//
674 // UnreachableInst Implementation
675 //===----------------------------------------------------------------------===//
676 
678  Instruction *InsertBefore)
679  : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable,
680  nullptr, 0, InsertBefore) {
681 }
683  : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable,
684  nullptr, 0, InsertAtEnd) {
685 }
686 
687 unsigned UnreachableInst::getNumSuccessorsV() const {
688  return getNumSuccessors();
689 }
690 
691 void UnreachableInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) {
692  llvm_unreachable("UnreachableInst has no successors!");
693 }
694 
695 BasicBlock *UnreachableInst::getSuccessorV(unsigned idx) const {
696  llvm_unreachable("UnreachableInst has no successors!");
697 }
698 
699 //===----------------------------------------------------------------------===//
700 // BranchInst Implementation
701 //===----------------------------------------------------------------------===//
702 
703 void BranchInst::AssertOK() {
704  if (isConditional())
705  assert(getCondition()->getType()->isIntegerTy(1) &&
706  "May only branch on boolean predicates!");
707 }
708 
709 BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore)
710  : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
711  OperandTraits<BranchInst>::op_end(this) - 1,
712  1, InsertBefore) {
713  assert(IfTrue && "Branch destination may not be null!");
714  Op<-1>() = IfTrue;
715 }
716 BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
717  Instruction *InsertBefore)
718  : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
719  OperandTraits<BranchInst>::op_end(this) - 3,
720  3, InsertBefore) {
721  Op<-1>() = IfTrue;
722  Op<-2>() = IfFalse;
723  Op<-3>() = Cond;
724 #ifndef NDEBUG
725  AssertOK();
726 #endif
727 }
728 
729 BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd)
730  : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
731  OperandTraits<BranchInst>::op_end(this) - 1,
732  1, InsertAtEnd) {
733  assert(IfTrue && "Branch destination may not be null!");
734  Op<-1>() = IfTrue;
735 }
736 
737 BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
738  BasicBlock *InsertAtEnd)
739  : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
740  OperandTraits<BranchInst>::op_end(this) - 3,
741  3, InsertAtEnd) {
742  Op<-1>() = IfTrue;
743  Op<-2>() = IfFalse;
744  Op<-3>() = Cond;
745 #ifndef NDEBUG
746  AssertOK();
747 #endif
748 }
749 
750 
751 BranchInst::BranchInst(const BranchInst &BI) :
752  TerminatorInst(Type::getVoidTy(BI.getContext()), Instruction::Br,
753  OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(),
754  BI.getNumOperands()) {
755  Op<-1>() = BI.Op<-1>();
756  if (BI.getNumOperands() != 1) {
757  assert(BI.getNumOperands() == 3 && "BR can have 1 or 3 operands!");
758  Op<-3>() = BI.Op<-3>();
759  Op<-2>() = BI.Op<-2>();
760  }
762 }
763 
765  assert(isConditional() &&
766  "Cannot swap successors of an unconditional branch");
767  Op<-1>().swap(Op<-2>());
768 
769  // Update profile metadata if present and it matches our structural
770  // expectations.
771  MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
772  if (!ProfileData || ProfileData->getNumOperands() != 3)
773  return;
774 
775  // The first operand is the name. Fetch them backwards and build a new one.
776  Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
777  ProfileData->getOperand(1)};
779  MDNode::get(ProfileData->getContext(), Ops));
780 }
781 
782 BasicBlock *BranchInst::getSuccessorV(unsigned idx) const {
783  return getSuccessor(idx);
784 }
785 unsigned BranchInst::getNumSuccessorsV() const {
786  return getNumSuccessors();
787 }
788 void BranchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
789  setSuccessor(idx, B);
790 }
791 
792 
793 //===----------------------------------------------------------------------===//
794 // AllocaInst Implementation
795 //===----------------------------------------------------------------------===//
796 
797 static Value *getAISize(LLVMContext &Context, Value *Amt) {
798  if (!Amt)
799  Amt = ConstantInt::get(Type::getInt32Ty(Context), 1);
800  else {
801  assert(!isa<BasicBlock>(Amt) &&
802  "Passed basic block into allocation size parameter! Use other ctor");
803  assert(Amt->getType()->isIntegerTy() &&
804  "Allocation array size is not an integer!");
805  }
806  return Amt;
807 }
808 
809 AllocaInst::AllocaInst(Type *Ty, const Twine &Name, Instruction *InsertBefore)
810  : AllocaInst(Ty, /*ArraySize=*/nullptr, Name, InsertBefore) {}
811 
812 AllocaInst::AllocaInst(Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd)
813  : AllocaInst(Ty, /*ArraySize=*/nullptr, Name, InsertAtEnd) {}
814 
815 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, const Twine &Name,
816  Instruction *InsertBefore)
817  : AllocaInst(Ty, ArraySize, /*Align=*/0, Name, InsertBefore) {}
818 
819 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, const Twine &Name,
820  BasicBlock *InsertAtEnd)
821  : AllocaInst(Ty, ArraySize, /*Align=*/0, Name, InsertAtEnd) {}
822 
823 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
824  const Twine &Name, Instruction *InsertBefore)
825  : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
826  getAISize(Ty->getContext(), ArraySize), InsertBefore),
827  AllocatedType(Ty) {
828  setAlignment(Align);
829  assert(!Ty->isVoidTy() && "Cannot allocate void!");
830  setName(Name);
831 }
832 
833 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize, unsigned Align,
834  const Twine &Name, BasicBlock *InsertAtEnd)
835  : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
836  getAISize(Ty->getContext(), ArraySize), InsertAtEnd),
837  AllocatedType(Ty) {
838  setAlignment(Align);
839  assert(!Ty->isVoidTy() && "Cannot allocate void!");
840  setName(Name);
841 }
842 
843 // Out of line virtual method, so the vtable, etc has a home.
845 }
846 
848  assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
849  assert(Align <= MaximumAlignment &&
850  "Alignment is greater than MaximumAlignment!");
851  setInstructionSubclassData((getSubclassDataFromInstruction() & ~31) |
852  (Log2_32(Align) + 1));
853  assert(getAlignment() == Align && "Alignment representation error!");
854 }
855 
857  if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0)))
858  return !CI->isOne();
859  return true;
860 }
861 
862 /// isStaticAlloca - Return true if this alloca is in the entry block of the
863 /// function and is a constant size. If so, the code generator will fold it
864 /// into the prolog/epilog code, so it is basically free.
866  // Must be constant size.
867  if (!isa<ConstantInt>(getArraySize())) return false;
868 
869  // Must be in the entry block.
870  const BasicBlock *Parent = getParent();
871  return Parent == &Parent->getParent()->front() && !isUsedWithInAlloca();
872 }
873 
874 //===----------------------------------------------------------------------===//
875 // LoadInst Implementation
876 //===----------------------------------------------------------------------===//
877 
878 void LoadInst::AssertOK() {
879  assert(getOperand(0)->getType()->isPointerTy() &&
880  "Ptr must have pointer type.");
881  assert(!(isAtomic() && getAlignment() == 0) &&
882  "Alignment required for atomic load");
883 }
884 
885 LoadInst::LoadInst(Value *Ptr, const Twine &Name, Instruction *InsertBef)
886  : LoadInst(Ptr, Name, /*isVolatile=*/false, InsertBef) {}
887 
888 LoadInst::LoadInst(Value *Ptr, const Twine &Name, BasicBlock *InsertAE)
889  : LoadInst(Ptr, Name, /*isVolatile=*/false, InsertAE) {}
890 
892  Instruction *InsertBef)
893  : LoadInst(Ty, Ptr, Name, isVolatile, /*Align=*/0, InsertBef) {}
894 
896  BasicBlock *InsertAE)
897  : LoadInst(Ptr, Name, isVolatile, /*Align=*/0, InsertAE) {}
898 
900  unsigned Align, Instruction *InsertBef)
901  : LoadInst(Ty, Ptr, Name, isVolatile, Align, NotAtomic, CrossThread,
902  InsertBef) {}
903 
905  unsigned Align, BasicBlock *InsertAE)
906  : LoadInst(Ptr, Name, isVolatile, Align, NotAtomic, CrossThread, InsertAE) {
907 }
908 
910  unsigned Align, AtomicOrdering Order,
911  SynchronizationScope SynchScope, Instruction *InsertBef)
912  : UnaryInstruction(Ty, Load, Ptr, InsertBef) {
913  assert(Ty == cast<PointerType>(Ptr->getType())->getElementType());
914  setVolatile(isVolatile);
915  setAlignment(Align);
916  setAtomic(Order, SynchScope);
917  AssertOK();
918  setName(Name);
919 }
920 
922  unsigned Align, AtomicOrdering Order,
923  SynchronizationScope SynchScope,
924  BasicBlock *InsertAE)
925  : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
926  Load, Ptr, InsertAE) {
927  setVolatile(isVolatile);
928  setAlignment(Align);
929  setAtomic(Order, SynchScope);
930  AssertOK();
931  setName(Name);
932 }
933 
934 LoadInst::LoadInst(Value *Ptr, const char *Name, Instruction *InsertBef)
935  : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
936  Load, Ptr, InsertBef) {
937  setVolatile(false);
938  setAlignment(0);
940  AssertOK();
941  if (Name && Name[0]) setName(Name);
942 }
943 
944 LoadInst::LoadInst(Value *Ptr, const char *Name, BasicBlock *InsertAE)
945  : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
946  Load, Ptr, InsertAE) {
947  setVolatile(false);
948  setAlignment(0);
950  AssertOK();
951  if (Name && Name[0]) setName(Name);
952 }
953 
954 LoadInst::LoadInst(Type *Ty, Value *Ptr, const char *Name, bool isVolatile,
955  Instruction *InsertBef)
956  : UnaryInstruction(Ty, Load, Ptr, InsertBef) {
957  assert(Ty == cast<PointerType>(Ptr->getType())->getElementType());
958  setVolatile(isVolatile);
959  setAlignment(0);
961  AssertOK();
962  if (Name && Name[0]) setName(Name);
963 }
964 
965 LoadInst::LoadInst(Value *Ptr, const char *Name, bool isVolatile,
966  BasicBlock *InsertAE)
967  : UnaryInstruction(cast<PointerType>(Ptr->getType())->getElementType(),
968  Load, Ptr, InsertAE) {
969  setVolatile(isVolatile);
970  setAlignment(0);
972  AssertOK();
973  if (Name && Name[0]) setName(Name);
974 }
975 
977  assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
978  assert(Align <= MaximumAlignment &&
979  "Alignment is greater than MaximumAlignment!");
980  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
981  ((Log2_32(Align)+1)<<1));
982  assert(getAlignment() == Align && "Alignment representation error!");
983 }
984 
985 //===----------------------------------------------------------------------===//
986 // StoreInst Implementation
987 //===----------------------------------------------------------------------===//
988 
989 void StoreInst::AssertOK() {
990  assert(getOperand(0) && getOperand(1) && "Both operands must be non-null!");
991  assert(getOperand(1)->getType()->isPointerTy() &&
992  "Ptr must have pointer type!");
993  assert(getOperand(0)->getType() ==
994  cast<PointerType>(getOperand(1)->getType())->getElementType()
995  && "Ptr must be a pointer to Val type!");
996  assert(!(isAtomic() && getAlignment() == 0) &&
997  "Alignment required for atomic store");
998 }
999 
1001  : StoreInst(val, addr, /*isVolatile=*/false, InsertBefore) {}
1002 
1004  : StoreInst(val, addr, /*isVolatile=*/false, InsertAtEnd) {}
1005 
1007  Instruction *InsertBefore)
1008  : StoreInst(val, addr, isVolatile, /*Align=*/0, InsertBefore) {}
1009 
1011  BasicBlock *InsertAtEnd)
1012  : StoreInst(val, addr, isVolatile, /*Align=*/0, InsertAtEnd) {}
1013 
1015  Instruction *InsertBefore)
1016  : StoreInst(val, addr, isVolatile, Align, NotAtomic, CrossThread,
1017  InsertBefore) {}
1018 
1020  BasicBlock *InsertAtEnd)
1021  : StoreInst(val, addr, isVolatile, Align, NotAtomic, CrossThread,
1022  InsertAtEnd) {}
1023 
1025  unsigned Align, AtomicOrdering Order,
1026  SynchronizationScope SynchScope,
1027  Instruction *InsertBefore)
1028  : Instruction(Type::getVoidTy(val->getContext()), Store,
1029  OperandTraits<StoreInst>::op_begin(this),
1030  OperandTraits<StoreInst>::operands(this),
1031  InsertBefore) {
1032  Op<0>() = val;
1033  Op<1>() = addr;
1034  setVolatile(isVolatile);
1035  setAlignment(Align);
1036  setAtomic(Order, SynchScope);
1037  AssertOK();
1038 }
1039 
1041  unsigned Align, AtomicOrdering Order,
1042  SynchronizationScope SynchScope,
1043  BasicBlock *InsertAtEnd)
1044  : Instruction(Type::getVoidTy(val->getContext()), Store,
1045  OperandTraits<StoreInst>::op_begin(this),
1046  OperandTraits<StoreInst>::operands(this),
1047  InsertAtEnd) {
1048  Op<0>() = val;
1049  Op<1>() = addr;
1050  setVolatile(isVolatile);
1051  setAlignment(Align);
1052  setAtomic(Order, SynchScope);
1053  AssertOK();
1054 }
1055 
1057  assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
1058  assert(Align <= MaximumAlignment &&
1059  "Alignment is greater than MaximumAlignment!");
1060  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
1061  ((Log2_32(Align)+1) << 1));
1062  assert(getAlignment() == Align && "Alignment representation error!");
1063 }
1064 
1065 //===----------------------------------------------------------------------===//
1066 // AtomicCmpXchgInst Implementation
1067 //===----------------------------------------------------------------------===//
1068 
1069 void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal,
1070  AtomicOrdering SuccessOrdering,
1071  AtomicOrdering FailureOrdering,
1072  SynchronizationScope SynchScope) {
1073  Op<0>() = Ptr;
1074  Op<1>() = Cmp;
1075  Op<2>() = NewVal;
1076  setSuccessOrdering(SuccessOrdering);
1077  setFailureOrdering(FailureOrdering);
1078  setSynchScope(SynchScope);
1079 
1080  assert(getOperand(0) && getOperand(1) && getOperand(2) &&
1081  "All operands must be non-null!");
1082  assert(getOperand(0)->getType()->isPointerTy() &&
1083  "Ptr must have pointer type!");
1084  assert(getOperand(1)->getType() ==
1085  cast<PointerType>(getOperand(0)->getType())->getElementType()
1086  && "Ptr must be a pointer to Cmp type!");
1087  assert(getOperand(2)->getType() ==
1088  cast<PointerType>(getOperand(0)->getType())->getElementType()
1089  && "Ptr must be a pointer to NewVal type!");
1090  assert(SuccessOrdering != NotAtomic &&
1091  "AtomicCmpXchg instructions must be atomic!");
1092  assert(FailureOrdering != NotAtomic &&
1093  "AtomicCmpXchg instructions must be atomic!");
1094  assert(SuccessOrdering >= FailureOrdering &&
1095  "AtomicCmpXchg success ordering must be at least as strong as fail");
1096  assert(FailureOrdering != Release && FailureOrdering != AcquireRelease &&
1097  "AtomicCmpXchg failure ordering cannot include release semantics");
1098 }
1099 
1101  AtomicOrdering SuccessOrdering,
1102  AtomicOrdering FailureOrdering,
1103  SynchronizationScope SynchScope,
1104  Instruction *InsertBefore)
1105  : Instruction(
1106  StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext()),
1107  nullptr),
1108  AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this),
1109  OperandTraits<AtomicCmpXchgInst>::operands(this), InsertBefore) {
1110  Init(Ptr, Cmp, NewVal, SuccessOrdering, FailureOrdering, SynchScope);
1111 }
1112 
1114  AtomicOrdering SuccessOrdering,
1115  AtomicOrdering FailureOrdering,
1116  SynchronizationScope SynchScope,
1117  BasicBlock *InsertAtEnd)
1118  : Instruction(
1119  StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext()),
1120  nullptr),
1121  AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this),
1122  OperandTraits<AtomicCmpXchgInst>::operands(this), InsertAtEnd) {
1123  Init(Ptr, Cmp, NewVal, SuccessOrdering, FailureOrdering, SynchScope);
1124 }
1125 
1126 //===----------------------------------------------------------------------===//
1127 // AtomicRMWInst Implementation
1128 //===----------------------------------------------------------------------===//
1129 
1130 void AtomicRMWInst::Init(BinOp Operation, Value *Ptr, Value *Val,
1131  AtomicOrdering Ordering,
1132  SynchronizationScope SynchScope) {
1133  Op<0>() = Ptr;
1134  Op<1>() = Val;
1135  setOperation(Operation);
1136  setOrdering(Ordering);
1137  setSynchScope(SynchScope);
1138 
1139  assert(getOperand(0) && getOperand(1) &&
1140  "All operands must be non-null!");
1141  assert(getOperand(0)->getType()->isPointerTy() &&
1142  "Ptr must have pointer type!");
1143  assert(getOperand(1)->getType() ==
1144  cast<PointerType>(getOperand(0)->getType())->getElementType()
1145  && "Ptr must be a pointer to Val type!");
1146  assert(Ordering != NotAtomic &&
1147  "AtomicRMW instructions must be atomic!");
1148 }
1149 
1151  AtomicOrdering Ordering,
1152  SynchronizationScope SynchScope,
1153  Instruction *InsertBefore)
1154  : Instruction(Val->getType(), AtomicRMW,
1155  OperandTraits<AtomicRMWInst>::op_begin(this),
1156  OperandTraits<AtomicRMWInst>::operands(this),
1157  InsertBefore) {
1158  Init(Operation, Ptr, Val, Ordering, SynchScope);
1159 }
1160 
1162  AtomicOrdering Ordering,
1163  SynchronizationScope SynchScope,
1164  BasicBlock *InsertAtEnd)
1165  : Instruction(Val->getType(), AtomicRMW,
1166  OperandTraits<AtomicRMWInst>::op_begin(this),
1167  OperandTraits<AtomicRMWInst>::operands(this),
1168  InsertAtEnd) {
1169  Init(Operation, Ptr, Val, Ordering, SynchScope);
1170 }
1171 
1172 //===----------------------------------------------------------------------===//
1173 // FenceInst Implementation
1174 //===----------------------------------------------------------------------===//
1175 
1177  SynchronizationScope SynchScope,
1178  Instruction *InsertBefore)
1179  : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) {
1180  setOrdering(Ordering);
1181  setSynchScope(SynchScope);
1182 }
1183 
1185  SynchronizationScope SynchScope,
1186  BasicBlock *InsertAtEnd)
1187  : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) {
1188  setOrdering(Ordering);
1189  setSynchScope(SynchScope);
1190 }
1191 
1192 //===----------------------------------------------------------------------===//
1193 // GetElementPtrInst Implementation
1194 //===----------------------------------------------------------------------===//
1195 
1196 void GetElementPtrInst::init(Value *Ptr, ArrayRef<Value *> IdxList,
1197  const Twine &Name) {
1198  assert(getNumOperands() == 1 + IdxList.size() &&
1199  "NumOperands not initialized?");
1200  Op<0>() = Ptr;
1201  std::copy(IdxList.begin(), IdxList.end(), op_begin() + 1);
1202  setName(Name);
1203 }
1204 
1205 GetElementPtrInst::GetElementPtrInst(const GetElementPtrInst &GEPI)
1206  : Instruction(GEPI.getType(), GetElementPtr,
1207  OperandTraits<GetElementPtrInst>::op_end(this) -
1208  GEPI.getNumOperands(),
1209  GEPI.getNumOperands()),
1210  SourceElementType(GEPI.SourceElementType),
1211  ResultElementType(GEPI.ResultElementType) {
1212  std::copy(GEPI.op_begin(), GEPI.op_end(), op_begin());
1214 }
1215 
1216 /// getIndexedType - Returns the type of the element that would be accessed with
1217 /// a gep instruction with the specified parameters.
1218 ///
1219 /// The Idxs pointer should point to a continuous piece of memory containing the
1220 /// indices, either as Value* or uint64_t.
1221 ///
1222 /// A null type is returned if the indices are invalid for the specified
1223 /// pointer type.
1224 ///
1225 template <typename IndexTy>
1227  // Handle the special case of the empty set index set, which is always valid.
1228  if (IdxList.empty())
1229  return Agg;
1230 
1231  // If there is at least one index, the top level type must be sized, otherwise
1232  // it cannot be 'stepped over'.
1233  if (!Agg->isSized())
1234  return nullptr;
1235 
1236  unsigned CurIdx = 1;
1237  for (; CurIdx != IdxList.size(); ++CurIdx) {
1238  CompositeType *CT = dyn_cast<CompositeType>(Agg);
1239  if (!CT || CT->isPointerTy()) return nullptr;
1240  IndexTy Index = IdxList[CurIdx];
1241  if (!CT->indexValid(Index)) return nullptr;
1242  Agg = CT->getTypeAtIndex(Index);
1243  }
1244  return CurIdx == IdxList.size() ? Agg : nullptr;
1245 }
1246 
1248  return getIndexedTypeInternal(Ty, IdxList);
1249 }
1250 
1252  ArrayRef<Constant *> IdxList) {
1253  return getIndexedTypeInternal(Ty, IdxList);
1254 }
1255 
1257  return getIndexedTypeInternal(Ty, IdxList);
1258 }
1259 
1260 /// hasAllZeroIndices - Return true if all of the indices of this GEP are
1261 /// zeros. If so, the result pointer and the first operand have the same
1262 /// value, just potentially different types.
1264  for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
1265  if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(i))) {
1266  if (!CI->isZero()) return false;
1267  } else {
1268  return false;
1269  }
1270  }
1271  return true;
1272 }
1273 
1274 /// hasAllConstantIndices - Return true if all of the indices of this GEP are
1275 /// constant integers. If so, the result pointer and the first operand have
1276 /// a constant offset between them.
1278  for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
1279  if (!isa<ConstantInt>(getOperand(i)))
1280  return false;
1281  }
1282  return true;
1283 }
1284 
1286  cast<GEPOperator>(this)->setIsInBounds(B);
1287 }
1288 
1290  return cast<GEPOperator>(this)->isInBounds();
1291 }
1292 
1294  APInt &Offset) const {
1295  // Delegate to the generic GEPOperator implementation.
1296  return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset);
1297 }
1298 
1299 //===----------------------------------------------------------------------===//
1300 // ExtractElementInst Implementation
1301 //===----------------------------------------------------------------------===//
1302 
1303 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
1304  const Twine &Name,
1305  Instruction *InsertBef)
1306  : Instruction(cast<VectorType>(Val->getType())->getElementType(),
1308  OperandTraits<ExtractElementInst>::op_begin(this),
1309  2, InsertBef) {
1310  assert(isValidOperands(Val, Index) &&
1311  "Invalid extractelement instruction operands!");
1312  Op<0>() = Val;
1313  Op<1>() = Index;
1314  setName(Name);
1315 }
1316 
1317 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
1318  const Twine &Name,
1319  BasicBlock *InsertAE)
1320  : Instruction(cast<VectorType>(Val->getType())->getElementType(),
1322  OperandTraits<ExtractElementInst>::op_begin(this),
1323  2, InsertAE) {
1324  assert(isValidOperands(Val, Index) &&
1325  "Invalid extractelement instruction operands!");
1326 
1327  Op<0>() = Val;
1328  Op<1>() = Index;
1329  setName(Name);
1330 }
1331 
1332 
1333 bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
1334  if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy())
1335  return false;
1336  return true;
1337 }
1338 
1339 
1340 //===----------------------------------------------------------------------===//
1341 // InsertElementInst Implementation
1342 //===----------------------------------------------------------------------===//
1343 
1344 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
1345  const Twine &Name,
1346  Instruction *InsertBef)
1347  : Instruction(Vec->getType(), InsertElement,
1348  OperandTraits<InsertElementInst>::op_begin(this),
1349  3, InsertBef) {
1350  assert(isValidOperands(Vec, Elt, Index) &&
1351  "Invalid insertelement instruction operands!");
1352  Op<0>() = Vec;
1353  Op<1>() = Elt;
1354  Op<2>() = Index;
1355  setName(Name);
1356 }
1357 
1358 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
1359  const Twine &Name,
1360  BasicBlock *InsertAE)
1361  : Instruction(Vec->getType(), InsertElement,
1362  OperandTraits<InsertElementInst>::op_begin(this),
1363  3, InsertAE) {
1364  assert(isValidOperands(Vec, Elt, Index) &&
1365  "Invalid insertelement instruction operands!");
1366 
1367  Op<0>() = Vec;
1368  Op<1>() = Elt;
1369  Op<2>() = Index;
1370  setName(Name);
1371 }
1372 
1373 bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
1374  const Value *Index) {
1375  if (!Vec->getType()->isVectorTy())
1376  return false; // First operand of insertelement must be vector type.
1377 
1378  if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType())
1379  return false;// Second operand of insertelement must be vector element type.
1380 
1381  if (!Index->getType()->isIntegerTy())
1382  return false; // Third operand of insertelement must be i32.
1383  return true;
1384 }
1385 
1386 
1387 //===----------------------------------------------------------------------===//
1388 // ShuffleVectorInst Implementation
1389 //===----------------------------------------------------------------------===//
1390 
1392  const Twine &Name,
1393  Instruction *InsertBefore)
1394 : Instruction(VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
1395  cast<VectorType>(Mask->getType())->getNumElements()),
1396  ShuffleVector,
1397  OperandTraits<ShuffleVectorInst>::op_begin(this),
1398  OperandTraits<ShuffleVectorInst>::operands(this),
1399  InsertBefore) {
1400  assert(isValidOperands(V1, V2, Mask) &&
1401  "Invalid shuffle vector instruction operands!");
1402  Op<0>() = V1;
1403  Op<1>() = V2;
1404  Op<2>() = Mask;
1405  setName(Name);
1406 }
1407 
1409  const Twine &Name,
1410  BasicBlock *InsertAtEnd)
1411 : Instruction(VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
1412  cast<VectorType>(Mask->getType())->getNumElements()),
1413  ShuffleVector,
1414  OperandTraits<ShuffleVectorInst>::op_begin(this),
1415  OperandTraits<ShuffleVectorInst>::operands(this),
1416  InsertAtEnd) {
1417  assert(isValidOperands(V1, V2, Mask) &&
1418  "Invalid shuffle vector instruction operands!");
1419 
1420  Op<0>() = V1;
1421  Op<1>() = V2;
1422  Op<2>() = Mask;
1423  setName(Name);
1424 }
1425 
1427  const Value *Mask) {
1428  // V1 and V2 must be vectors of the same type.
1429  if (!V1->getType()->isVectorTy() || V1->getType() != V2->getType())
1430  return false;
1431 
1432  // Mask must be vector of i32.
1433  VectorType *MaskTy = dyn_cast<VectorType>(Mask->getType());
1434  if (!MaskTy || !MaskTy->getElementType()->isIntegerTy(32))
1435  return false;
1436 
1437  // Check to see if Mask is valid.
1438  if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask))
1439  return true;
1440 
1441  if (const ConstantVector *MV = dyn_cast<ConstantVector>(Mask)) {
1442  unsigned V1Size = cast<VectorType>(V1->getType())->getNumElements();
1443  for (Value *Op : MV->operands()) {
1444  if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
1445  if (CI->uge(V1Size*2))
1446  return false;
1447  } else if (!isa<UndefValue>(Op)) {
1448  return false;
1449  }
1450  }
1451  return true;
1452  }
1453 
1454  if (const ConstantDataSequential *CDS =
1455  dyn_cast<ConstantDataSequential>(Mask)) {
1456  unsigned V1Size = cast<VectorType>(V1->getType())->getNumElements();
1457  for (unsigned i = 0, e = MaskTy->getNumElements(); i != e; ++i)
1458  if (CDS->getElementAsInteger(i) >= V1Size*2)
1459  return false;
1460  return true;
1461  }
1462 
1463  // The bitcode reader can create a place holder for a forward reference
1464  // used as the shuffle mask. When this occurs, the shuffle mask will
1465  // fall into this case and fail. To avoid this error, do this bit of
1466  // ugliness to allow such a mask pass.
1467  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(Mask))
1468  if (CE->getOpcode() == Instruction::UserOp1)
1469  return true;
1470 
1471  return false;
1472 }
1473 
1474 /// getMaskValue - Return the index from the shuffle mask for the specified
1475 /// output result. This is either -1 if the element is undef or a number less
1476 /// than 2*numelements.
1478  assert(i < Mask->getType()->getVectorNumElements() && "Index out of range");
1479  if (ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(Mask))
1480  return CDS->getElementAsInteger(i);
1481  Constant *C = Mask->getAggregateElement(i);
1482  if (isa<UndefValue>(C))
1483  return -1;
1484  return cast<ConstantInt>(C)->getZExtValue();
1485 }
1486 
1487 /// getShuffleMask - Return the full mask for this instruction, where each
1488 /// element is the element number and undef's are returned as -1.
1490  SmallVectorImpl<int> &Result) {
1491  unsigned NumElts = Mask->getType()->getVectorNumElements();
1492 
1493  if (ConstantDataSequential *CDS=dyn_cast<ConstantDataSequential>(Mask)) {
1494  for (unsigned i = 0; i != NumElts; ++i)
1495  Result.push_back(CDS->getElementAsInteger(i));
1496  return;
1497  }
1498  for (unsigned i = 0; i != NumElts; ++i) {
1499  Constant *C = Mask->getAggregateElement(i);
1500  Result.push_back(isa<UndefValue>(C) ? -1 :
1501  cast<ConstantInt>(C)->getZExtValue());
1502  }
1503 }
1504 
1505 
1506 //===----------------------------------------------------------------------===//
1507 // InsertValueInst Class
1508 //===----------------------------------------------------------------------===//
1509 
1510 void InsertValueInst::init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
1511  const Twine &Name) {
1512  assert(getNumOperands() == 2 && "NumOperands not initialized?");
1513 
1514  // There's no fundamental reason why we require at least one index
1515  // (other than weirdness with &*IdxBegin being invalid; see
1516  // getelementptr's init routine for example). But there's no
1517  // present need to support it.
1518  assert(Idxs.size() > 0 && "InsertValueInst must have at least one index");
1519 
1520  assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs) ==
1521  Val->getType() && "Inserted value must match indexed type!");
1522  Op<0>() = Agg;
1523  Op<1>() = Val;
1524 
1525  Indices.append(Idxs.begin(), Idxs.end());
1526  setName(Name);
1527 }
1528 
1529 InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
1530  : Instruction(IVI.getType(), InsertValue,
1531  OperandTraits<InsertValueInst>::op_begin(this), 2),
1532  Indices(IVI.Indices) {
1533  Op<0>() = IVI.getOperand(0);
1534  Op<1>() = IVI.getOperand(1);
1536 }
1537 
1538 //===----------------------------------------------------------------------===//
1539 // ExtractValueInst Class
1540 //===----------------------------------------------------------------------===//
1541 
1542 void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) {
1543  assert(getNumOperands() == 1 && "NumOperands not initialized?");
1544 
1545  // There's no fundamental reason why we require at least one index.
1546  // But there's no present need to support it.
1547  assert(Idxs.size() > 0 && "ExtractValueInst must have at least one index");
1548 
1549  Indices.append(Idxs.begin(), Idxs.end());
1550  setName(Name);
1551 }
1552 
1553 ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI)
1554  : UnaryInstruction(EVI.getType(), ExtractValue, EVI.getOperand(0)),
1555  Indices(EVI.Indices) {
1557 }
1558 
1559 // getIndexedType - Returns the type of the element that would be extracted
1560 // with an extractvalue instruction with the specified parameters.
1561 //
1562 // A null type is returned if the indices are invalid for the specified
1563 // pointer type.
1564 //
1566  ArrayRef<unsigned> Idxs) {
1567  for (unsigned Index : Idxs) {
1568  // We can't use CompositeType::indexValid(Index) here.
1569  // indexValid() always returns true for arrays because getelementptr allows
1570  // out-of-bounds indices. Since we don't allow those for extractvalue and
1571  // insertvalue we need to check array indexing manually.
1572  // Since the only other types we can index into are struct types it's just
1573  // as easy to check those manually as well.
1574  if (ArrayType *AT = dyn_cast<ArrayType>(Agg)) {
1575  if (Index >= AT->getNumElements())
1576  return nullptr;
1577  } else if (StructType *ST = dyn_cast<StructType>(Agg)) {
1578  if (Index >= ST->getNumElements())
1579  return nullptr;
1580  } else {
1581  // Not a valid type to index into.
1582  return nullptr;
1583  }
1584 
1585  Agg = cast<CompositeType>(Agg)->getTypeAtIndex(Index);
1586  }
1587  return const_cast<Type*>(Agg);
1588 }
1589 
1590 //===----------------------------------------------------------------------===//
1591 // BinaryOperator Class
1592 //===----------------------------------------------------------------------===//
1593 
1595  Type *Ty, const Twine &Name,
1596  Instruction *InsertBefore)
1597  : Instruction(Ty, iType,
1598  OperandTraits<BinaryOperator>::op_begin(this),
1599  OperandTraits<BinaryOperator>::operands(this),
1600  InsertBefore) {
1601  Op<0>() = S1;
1602  Op<1>() = S2;
1603  init(iType);
1604  setName(Name);
1605 }
1606 
1608  Type *Ty, const Twine &Name,
1609  BasicBlock *InsertAtEnd)
1610  : Instruction(Ty, iType,
1611  OperandTraits<BinaryOperator>::op_begin(this),
1612  OperandTraits<BinaryOperator>::operands(this),
1613  InsertAtEnd) {
1614  Op<0>() = S1;
1615  Op<1>() = S2;
1616  init(iType);
1617  setName(Name);
1618 }
1619 
1620 
1622  Value *LHS = getOperand(0), *RHS = getOperand(1);
1623  (void)LHS; (void)RHS; // Silence warnings.
1624  assert(LHS->getType() == RHS->getType() &&
1625  "Binary operator operand types must match!");
1626 #ifndef NDEBUG
1627  switch (iType) {
1628  case Add: case Sub:
1629  case Mul:
1630  assert(getType() == LHS->getType() &&
1631  "Arithmetic operation should return same type as operands!");
1632  assert(getType()->isIntOrIntVectorTy() &&
1633  "Tried to create an integer operation on a non-integer type!");
1634  break;
1635  case FAdd: case FSub:
1636  case FMul:
1637  assert(getType() == LHS->getType() &&
1638  "Arithmetic operation should return same type as operands!");
1639  assert(getType()->isFPOrFPVectorTy() &&
1640  "Tried to create a floating-point operation on a "
1641  "non-floating-point type!");
1642  break;
1643  case UDiv:
1644  case SDiv:
1645  assert(getType() == LHS->getType() &&
1646  "Arithmetic operation should return same type as operands!");
1647  assert((getType()->isIntegerTy() || (getType()->isVectorTy() &&
1648  cast<VectorType>(getType())->getElementType()->isIntegerTy())) &&
1649  "Incorrect operand type (not integer) for S/UDIV");
1650  break;
1651  case FDiv:
1652  assert(getType() == LHS->getType() &&
1653  "Arithmetic operation should return same type as operands!");
1654  assert(getType()->isFPOrFPVectorTy() &&
1655  "Incorrect operand type (not floating point) for FDIV");
1656  break;
1657  case URem:
1658  case SRem:
1659  assert(getType() == LHS->getType() &&
1660  "Arithmetic operation should return same type as operands!");
1661  assert((getType()->isIntegerTy() || (getType()->isVectorTy() &&
1662  cast<VectorType>(getType())->getElementType()->isIntegerTy())) &&
1663  "Incorrect operand type (not integer) for S/UREM");
1664  break;
1665  case FRem:
1666  assert(getType() == LHS->getType() &&
1667  "Arithmetic operation should return same type as operands!");
1668  assert(getType()->isFPOrFPVectorTy() &&
1669  "Incorrect operand type (not floating point) for FREM");
1670  break;
1671  case Shl:
1672  case LShr:
1673  case AShr:
1674  assert(getType() == LHS->getType() &&
1675  "Shift operation should return same type as operands!");
1676  assert((getType()->isIntegerTy() ||
1677  (getType()->isVectorTy() &&
1678  cast<VectorType>(getType())->getElementType()->isIntegerTy())) &&
1679  "Tried to create a shift operation on a non-integral type!");
1680  break;
1681  case And: case Or:
1682  case Xor:
1683  assert(getType() == LHS->getType() &&
1684  "Logical operation should return same type as operands!");
1685  assert((getType()->isIntegerTy() ||
1686  (getType()->isVectorTy() &&
1687  cast<VectorType>(getType())->getElementType()->isIntegerTy())) &&
1688  "Tried to create a logical operation on a non-integral type!");
1689  break;
1690  default:
1691  break;
1692  }
1693 #endif
1694 }
1695 
1697  const Twine &Name,
1698  Instruction *InsertBefore) {
1699  assert(S1->getType() == S2->getType() &&
1700  "Cannot create binary operator with two operands of differing type!");
1701  return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore);
1702 }
1703 
1705  const Twine &Name,
1706  BasicBlock *InsertAtEnd) {
1707  BinaryOperator *Res = Create(Op, S1, S2, Name);
1708  InsertAtEnd->getInstList().push_back(Res);
1709  return Res;
1710 }
1711 
1713  Instruction *InsertBefore) {
1715  return new BinaryOperator(Instruction::Sub,
1716  zero, Op,
1717  Op->getType(), Name, InsertBefore);
1718 }
1719 
1721  BasicBlock *InsertAtEnd) {
1723  return new BinaryOperator(Instruction::Sub,
1724  zero, Op,
1725  Op->getType(), Name, InsertAtEnd);
1726 }
1727 
1729  Instruction *InsertBefore) {
1731  return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertBefore);
1732 }
1733 
1735  BasicBlock *InsertAtEnd) {
1737  return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertAtEnd);
1738 }
1739 
1741  Instruction *InsertBefore) {
1743  return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertBefore);
1744 }
1745 
1747  BasicBlock *InsertAtEnd) {
1749  return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd);
1750 }
1751 
1753  Instruction *InsertBefore) {
1755  return new BinaryOperator(Instruction::FSub, zero, Op,
1756  Op->getType(), Name, InsertBefore);
1757 }
1758 
1760  BasicBlock *InsertAtEnd) {
1762  return new BinaryOperator(Instruction::FSub, zero, Op,
1763  Op->getType(), Name, InsertAtEnd);
1764 }
1765 
1767  Instruction *InsertBefore) {
1769  return new BinaryOperator(Instruction::Xor, Op, C,
1770  Op->getType(), Name, InsertBefore);
1771 }
1772 
1774  BasicBlock *InsertAtEnd) {
1775  Constant *AllOnes = Constant::getAllOnesValue(Op->getType());
1776  return new BinaryOperator(Instruction::Xor, Op, AllOnes,
1777  Op->getType(), Name, InsertAtEnd);
1778 }
1779 
1780 
1781 // isConstantAllOnes - Helper function for several functions below
1782 static inline bool isConstantAllOnes(const Value *V) {
1783  if (const Constant *C = dyn_cast<Constant>(V))
1784  return C->isAllOnesValue();
1785  return false;
1786 }
1787 
1789  if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V))
1790  if (Bop->getOpcode() == Instruction::Sub)
1791  if (Constant* C = dyn_cast<Constant>(Bop->getOperand(0)))
1792  return C->isNegativeZeroValue();
1793  return false;
1794 }
1795 
1796 bool BinaryOperator::isFNeg(const Value *V, bool IgnoreZeroSign) {
1797  if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V))
1798  if (Bop->getOpcode() == Instruction::FSub)
1799  if (Constant* C = dyn_cast<Constant>(Bop->getOperand(0))) {
1800  if (!IgnoreZeroSign)
1801  IgnoreZeroSign = cast<Instruction>(V)->hasNoSignedZeros();
1802  return !IgnoreZeroSign ? C->isNegativeZeroValue() : C->isZeroValue();
1803  }
1804  return false;
1805 }
1806 
1808  if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V))
1809  return (Bop->getOpcode() == Instruction::Xor &&
1810  (isConstantAllOnes(Bop->getOperand(1)) ||
1811  isConstantAllOnes(Bop->getOperand(0))));
1812  return false;
1813 }
1814 
1816  return cast<BinaryOperator>(BinOp)->getOperand(1);
1817 }
1818 
1820  return getNegArgument(const_cast<Value*>(BinOp));
1821 }
1822 
1824  return cast<BinaryOperator>(BinOp)->getOperand(1);
1825 }
1826 
1828  return getFNegArgument(const_cast<Value*>(BinOp));
1829 }
1830 
1832  assert(isNot(BinOp) && "getNotArgument on non-'not' instruction!");
1833  BinaryOperator *BO = cast<BinaryOperator>(BinOp);
1834  Value *Op0 = BO->getOperand(0);
1835  Value *Op1 = BO->getOperand(1);
1836  if (isConstantAllOnes(Op0)) return Op1;
1837 
1838  assert(isConstantAllOnes(Op1));
1839  return Op0;
1840 }
1841 
1843  return getNotArgument(const_cast<Value*>(BinOp));
1844 }
1845 
1846 
1847 // swapOperands - Exchange the two operands to this instruction. This
1848 // instruction is safe to use on any binary instruction and does not
1849 // modify the semantics of the instruction. If the instruction is
1850 // order dependent (SetLT f.e.) the opcode is changed.
1851 //
1853  if (!isCommutative())
1854  return true; // Can't commute operands
1855  Op<0>().swap(Op<1>());
1856  return false;
1857 }
1858 
1860  cast<OverflowingBinaryOperator>(this)->setHasNoUnsignedWrap(b);
1861 }
1862 
1864  cast<OverflowingBinaryOperator>(this)->setHasNoSignedWrap(b);
1865 }
1866 
1868  cast<PossiblyExactOperator>(this)->setIsExact(b);
1869 }
1870 
1872  return cast<OverflowingBinaryOperator>(this)->hasNoUnsignedWrap();
1873 }
1874 
1876  return cast<OverflowingBinaryOperator>(this)->hasNoSignedWrap();
1877 }
1878 
1880  return cast<PossiblyExactOperator>(this)->isExact();
1881 }
1882 
1884  // Copy the wrapping flags.
1885  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
1886  setHasNoSignedWrap(OB->hasNoSignedWrap());
1887  setHasNoUnsignedWrap(OB->hasNoUnsignedWrap());
1888  }
1889 
1890  // Copy the exact flag.
1891  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
1892  setIsExact(PE->isExact());
1893 
1894  // Copy the fast-math flags.
1895  if (auto *FP = dyn_cast<FPMathOperator>(V))
1896  copyFastMathFlags(FP->getFastMathFlags());
1897 }
1898 
1900  if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
1901  setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap());
1902  setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap());
1903  }
1904 
1905  if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
1906  setIsExact(isExact() & PE->isExact());
1907 
1908  if (auto *FP = dyn_cast<FPMathOperator>(V)) {
1910  FM &= FP->getFastMathFlags();
1911  copyFastMathFlags(FM);
1912  }
1913 }
1914 
1915 
1916 //===----------------------------------------------------------------------===//
1917 // FPMathOperator Class
1918 //===----------------------------------------------------------------------===//
1919 
1920 /// getFPAccuracy - Get the maximum error permitted by this operation in ULPs.
1921 /// An accuracy of 0.0 means that the operation should be performed with the
1922 /// default precision.
1924  const MDNode *MD =
1925  cast<Instruction>(this)->getMetadata(LLVMContext::MD_fpmath);
1926  if (!MD)
1927  return 0.0;
1928  ConstantFP *Accuracy = mdconst::extract<ConstantFP>(MD->getOperand(0));
1929  return Accuracy->getValueAPF().convertToFloat();
1930 }
1931 
1932 
1933 //===----------------------------------------------------------------------===//
1934 // CastInst Class
1935 //===----------------------------------------------------------------------===//
1936 
1937 void CastInst::anchor() {}
1938 
1939 // Just determine if this cast only deals with integral->integral conversion.
1941  switch (getOpcode()) {
1942  default: return false;
1943  case Instruction::ZExt:
1944  case Instruction::SExt:
1945  case Instruction::Trunc:
1946  return true;
1947  case Instruction::BitCast:
1948  return getOperand(0)->getType()->isIntegerTy() &&
1949  getType()->isIntegerTy();
1950  }
1951 }
1952 
1954  // Only BitCast can be lossless, exit fast if we're not BitCast
1955  if (getOpcode() != Instruction::BitCast)
1956  return false;
1957 
1958  // Identity cast is always lossless
1959  Type* SrcTy = getOperand(0)->getType();
1960  Type* DstTy = getType();
1961  if (SrcTy == DstTy)
1962  return true;
1963 
1964  // Pointer to pointer is always lossless.
1965  if (SrcTy->isPointerTy())
1966  return DstTy->isPointerTy();
1967  return false; // Other types have no identity values
1968 }
1969 
1970 /// This function determines if the CastInst does not require any bits to be
1971 /// changed in order to effect the cast. Essentially, it identifies cases where
1972 /// no code gen is necessary for the cast, hence the name no-op cast. For
1973 /// example, the following are all no-op casts:
1974 /// # bitcast i32* %x to i8*
1975 /// # bitcast <2 x i32> %x to <4 x i16>
1976 /// # ptrtoint i32* %x to i32 ; on 32-bit plaforms only
1977 /// @brief Determine if the described cast is a no-op.
1979  Type *SrcTy,
1980  Type *DestTy,
1981  Type *IntPtrTy) {
1982  switch (Opcode) {
1983  default: llvm_unreachable("Invalid CastOp");
1984  case Instruction::Trunc:
1985  case Instruction::ZExt:
1986  case Instruction::SExt:
1987  case Instruction::FPTrunc:
1988  case Instruction::FPExt:
1989  case Instruction::UIToFP:
1990  case Instruction::SIToFP:
1991  case Instruction::FPToUI:
1992  case Instruction::FPToSI:
1993  case Instruction::AddrSpaceCast:
1994  // TODO: Target informations may give a more accurate answer here.
1995  return false;
1996  case Instruction::BitCast:
1997  return true; // BitCast never modifies bits.
1998  case Instruction::PtrToInt:
1999  return IntPtrTy->getScalarSizeInBits() ==
2000  DestTy->getScalarSizeInBits();
2001  case Instruction::IntToPtr:
2002  return IntPtrTy->getScalarSizeInBits() ==
2003  SrcTy->getScalarSizeInBits();
2004  }
2005 }
2006 
2007 /// @brief Determine if a cast is a no-op.
2008 bool CastInst::isNoopCast(Type *IntPtrTy) const {
2009  return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy);
2010 }
2011 
2012 bool CastInst::isNoopCast(const DataLayout &DL) const {
2013  Type *PtrOpTy = nullptr;
2014  if (getOpcode() == Instruction::PtrToInt)
2015  PtrOpTy = getOperand(0)->getType();
2016  else if (getOpcode() == Instruction::IntToPtr)
2017  PtrOpTy = getType();
2018 
2019  Type *IntPtrTy =
2020  PtrOpTy ? DL.getIntPtrType(PtrOpTy) : DL.getIntPtrType(getContext(), 0);
2021 
2022  return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy);
2023 }
2024 
2025 /// This function determines if a pair of casts can be eliminated and what
2026 /// opcode should be used in the elimination. This assumes that there are two
2027 /// instructions like this:
2028 /// * %F = firstOpcode SrcTy %x to MidTy
2029 /// * %S = secondOpcode MidTy %F to DstTy
2030 /// The function returns a resultOpcode so these two casts can be replaced with:
2031 /// * %Replacement = resultOpcode %SrcTy %x to DstTy
2032 /// If no such cast is permited, the function returns 0.
2034  Instruction::CastOps firstOp, Instruction::CastOps secondOp,
2035  Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
2036  Type *DstIntPtrTy) {
2037  // Define the 144 possibilities for these two cast instructions. The values
2038  // in this matrix determine what to do in a given situation and select the
2039  // case in the switch below. The rows correspond to firstOp, the columns
2040  // correspond to secondOp. In looking at the table below, keep in mind
2041  // the following cast properties:
2042  //
2043  // Size Compare Source Destination
2044  // Operator Src ? Size Type Sign Type Sign
2045  // -------- ------------ ------------------- ---------------------
2046  // TRUNC > Integer Any Integral Any
2047  // ZEXT < Integral Unsigned Integer Any
2048  // SEXT < Integral Signed Integer Any
2049  // FPTOUI n/a FloatPt n/a Integral Unsigned
2050  // FPTOSI n/a FloatPt n/a Integral Signed
2051  // UITOFP n/a Integral Unsigned FloatPt n/a
2052  // SITOFP n/a Integral Signed FloatPt n/a
2053  // FPTRUNC > FloatPt n/a FloatPt n/a
2054  // FPEXT < FloatPt n/a FloatPt n/a
2055  // PTRTOINT n/a Pointer n/a Integral Unsigned
2056  // INTTOPTR n/a Integral Unsigned Pointer n/a
2057  // BITCAST = FirstClass n/a FirstClass n/a
2058  // ADDRSPCST n/a Pointer n/a Pointer n/a
2059  //
2060  // NOTE: some transforms are safe, but we consider them to be non-profitable.
2061  // For example, we could merge "fptoui double to i32" + "zext i32 to i64",
2062  // into "fptoui double to i64", but this loses information about the range
2063  // of the produced value (we no longer know the top-part is all zeros).
2064  // Further this conversion is often much more expensive for typical hardware,
2065  // and causes issues when building libgcc. We disallow fptosi+sext for the
2066  // same reason.
2067  const unsigned numCastOps =
2068  Instruction::CastOpsEnd - Instruction::CastOpsBegin;
2069  static const uint8_t CastResults[numCastOps][numCastOps] = {
2070  // T F F U S F F P I B A -+
2071  // R Z S P P I I T P 2 N T S |
2072  // U E E 2 2 2 2 R E I T C C +- secondOp
2073  // N X X U S F F N X N 2 V V |
2074  // C T T I I P P C T T P T T -+
2075  { 1, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // Trunc -+
2076  { 8, 1, 9,99,99, 2,17,99,99,99, 2, 3, 0}, // ZExt |
2077  { 8, 0, 1,99,99, 0, 2,99,99,99, 0, 3, 0}, // SExt |
2078  { 0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToUI |
2079  { 0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToSI |
2080  { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // UIToFP +- firstOp
2081  { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // SIToFP |
2082  { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // FPTrunc |
2083  { 99,99,99, 2, 2,99,99,10, 2,99,99, 4, 0}, // FPExt |
2084  { 1, 0, 0,99,99, 0, 0,99,99,99, 7, 3, 0}, // PtrToInt |
2085  { 99,99,99,99,99,99,99,99,99,11,99,15, 0}, // IntToPtr |
2086  { 5, 5, 5, 6, 6, 5, 5, 6, 6,16, 5, 1,14}, // BitCast |
2087  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,13,12}, // AddrSpaceCast -+
2088  };
2089 
2090  // If either of the casts are a bitcast from scalar to vector, disallow the
2091  // merging. However, bitcast of A->B->A are allowed.
2092  bool isFirstBitcast = (firstOp == Instruction::BitCast);
2093  bool isSecondBitcast = (secondOp == Instruction::BitCast);
2094  bool chainedBitcast = (SrcTy == DstTy && isFirstBitcast && isSecondBitcast);
2095 
2096  // Check if any of the bitcasts convert scalars<->vectors.
2097  if ((isFirstBitcast && isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) ||
2098  (isSecondBitcast && isa<VectorType>(MidTy) != isa<VectorType>(DstTy)))
2099  // Unless we are bitcasing to the original type, disallow optimizations.
2100  if (!chainedBitcast) return 0;
2101 
2102  int ElimCase = CastResults[firstOp-Instruction::CastOpsBegin]
2103  [secondOp-Instruction::CastOpsBegin];
2104  switch (ElimCase) {
2105  case 0:
2106  // Categorically disallowed.
2107  return 0;
2108  case 1:
2109  // Allowed, use first cast's opcode.
2110  return firstOp;
2111  case 2:
2112  // Allowed, use second cast's opcode.
2113  return secondOp;
2114  case 3:
2115  // No-op cast in second op implies firstOp as long as the DestTy
2116  // is integer and we are not converting between a vector and a
2117  // non-vector type.
2118  if (!SrcTy->isVectorTy() && DstTy->isIntegerTy())
2119  return firstOp;
2120  return 0;
2121  case 4:
2122  // No-op cast in second op implies firstOp as long as the DestTy
2123  // is floating point.
2124  if (DstTy->isFloatingPointTy())
2125  return firstOp;
2126  return 0;
2127  case 5:
2128  // No-op cast in first op implies secondOp as long as the SrcTy
2129  // is an integer.
2130  if (SrcTy->isIntegerTy())
2131  return secondOp;
2132  return 0;
2133  case 6:
2134  // No-op cast in first op implies secondOp as long as the SrcTy
2135  // is a floating point.
2136  if (SrcTy->isFloatingPointTy())
2137  return secondOp;
2138  return 0;
2139  case 7: {
2140  // Cannot simplify if address spaces are different!
2141  if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace())
2142  return 0;
2143 
2144  unsigned MidSize = MidTy->getScalarSizeInBits();
2145  // We can still fold this without knowing the actual sizes as long we
2146  // know that the intermediate pointer is the largest possible
2147  // pointer size.
2148  // FIXME: Is this always true?
2149  if (MidSize == 64)
2150  return Instruction::BitCast;
2151 
2152  // ptrtoint, inttoptr -> bitcast (ptr -> ptr) if int size is >= ptr size.
2153  if (!SrcIntPtrTy || DstIntPtrTy != SrcIntPtrTy)
2154  return 0;
2155  unsigned PtrSize = SrcIntPtrTy->getScalarSizeInBits();
2156  if (MidSize >= PtrSize)
2157  return Instruction::BitCast;
2158  return 0;
2159  }
2160  case 8: {
2161  // ext, trunc -> bitcast, if the SrcTy and DstTy are same size
2162  // ext, trunc -> ext, if sizeof(SrcTy) < sizeof(DstTy)
2163  // ext, trunc -> trunc, if sizeof(SrcTy) > sizeof(DstTy)
2164  unsigned SrcSize = SrcTy->getScalarSizeInBits();
2165  unsigned DstSize = DstTy->getScalarSizeInBits();
2166  if (SrcSize == DstSize)
2167  return Instruction::BitCast;
2168  else if (SrcSize < DstSize)
2169  return firstOp;
2170  return secondOp;
2171  }
2172  case 9:
2173  // zext, sext -> zext, because sext can't sign extend after zext
2174  return Instruction::ZExt;
2175  case 10:
2176  // fpext followed by ftrunc is allowed if the bit size returned to is
2177  // the same as the original, in which case its just a bitcast
2178  if (SrcTy == DstTy)
2179  return Instruction::BitCast;
2180  return 0; // If the types are not the same we can't eliminate it.
2181  case 11: {
2182  // inttoptr, ptrtoint -> bitcast if SrcSize<=PtrSize and SrcSize==DstSize
2183  if (!MidIntPtrTy)
2184  return 0;
2185  unsigned PtrSize = MidIntPtrTy->getScalarSizeInBits();
2186  unsigned SrcSize = SrcTy->getScalarSizeInBits();
2187  unsigned DstSize = DstTy->getScalarSizeInBits();
2188  if (SrcSize <= PtrSize && SrcSize == DstSize)
2189  return Instruction::BitCast;
2190  return 0;
2191  }
2192  case 12: {
2193  // addrspacecast, addrspacecast -> bitcast, if SrcAS == DstAS
2194  // addrspacecast, addrspacecast -> addrspacecast, if SrcAS != DstAS
2195  if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace())
2196  return Instruction::AddrSpaceCast;
2197  return Instruction::BitCast;
2198  }
2199  case 13:
2200  // FIXME: this state can be merged with (1), but the following assert
2201  // is useful to check the correcteness of the sequence due to semantic
2202  // change of bitcast.
2203  assert(
2204  SrcTy->isPtrOrPtrVectorTy() &&
2205  MidTy->isPtrOrPtrVectorTy() &&
2206  DstTy->isPtrOrPtrVectorTy() &&
2207  SrcTy->getPointerAddressSpace() != MidTy->getPointerAddressSpace() &&
2208  MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() &&
2209  "Illegal addrspacecast, bitcast sequence!");
2210  // Allowed, use first cast's opcode
2211  return firstOp;
2212  case 14:
2213  // bitcast, addrspacecast -> addrspacecast if the element type of
2214  // bitcast's source is the same as that of addrspacecast's destination.
2215  if (SrcTy->getPointerElementType() == DstTy->getPointerElementType())
2216  return Instruction::AddrSpaceCast;
2217  return 0;
2218 
2219  case 15:
2220  // FIXME: this state can be merged with (1), but the following assert
2221  // is useful to check the correcteness of the sequence due to semantic
2222  // change of bitcast.
2223  assert(
2224  SrcTy->isIntOrIntVectorTy() &&
2225  MidTy->isPtrOrPtrVectorTy() &&
2226  DstTy->isPtrOrPtrVectorTy() &&
2227  MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() &&
2228  "Illegal inttoptr, bitcast sequence!");
2229  // Allowed, use first cast's opcode
2230  return firstOp;
2231  case 16:
2232  // FIXME: this state can be merged with (2), but the following assert
2233  // is useful to check the correcteness of the sequence due to semantic
2234  // change of bitcast.
2235  assert(
2236  SrcTy->isPtrOrPtrVectorTy() &&
2237  MidTy->isPtrOrPtrVectorTy() &&
2238  DstTy->isIntOrIntVectorTy() &&
2239  SrcTy->getPointerAddressSpace() == MidTy->getPointerAddressSpace() &&
2240  "Illegal bitcast, ptrtoint sequence!");
2241  // Allowed, use second cast's opcode
2242  return secondOp;
2243  case 17:
2244  // (sitofp (zext x)) -> (uitofp x)
2245  return Instruction::UIToFP;
2246  case 99:
2247  // Cast combination can't happen (error in input). This is for all cases
2248  // where the MidTy is not the same for the two cast instructions.
2249  llvm_unreachable("Invalid Cast Combination");
2250  default:
2251  llvm_unreachable("Error in CastResults table!!!");
2252  }
2253 }
2254 
2256  const Twine &Name, Instruction *InsertBefore) {
2257  assert(castIsValid(op, S, Ty) && "Invalid cast!");
2258  // Construct and return the appropriate CastInst subclass
2259  switch (op) {
2260  case Trunc: return new TruncInst (S, Ty, Name, InsertBefore);
2261  case ZExt: return new ZExtInst (S, Ty, Name, InsertBefore);
2262  case SExt: return new SExtInst (S, Ty, Name, InsertBefore);
2263  case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertBefore);
2264  case FPExt: return new FPExtInst (S, Ty, Name, InsertBefore);
2265  case UIToFP: return new UIToFPInst (S, Ty, Name, InsertBefore);
2266  case SIToFP: return new SIToFPInst (S, Ty, Name, InsertBefore);
2267  case FPToUI: return new FPToUIInst (S, Ty, Name, InsertBefore);
2268  case FPToSI: return new FPToSIInst (S, Ty, Name, InsertBefore);
2269  case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertBefore);
2270  case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertBefore);
2271  case BitCast: return new BitCastInst (S, Ty, Name, InsertBefore);
2272  case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertBefore);
2273  default: llvm_unreachable("Invalid opcode provided");
2274  }
2275 }
2276 
2278  const Twine &Name, BasicBlock *InsertAtEnd) {
2279  assert(castIsValid(op, S, Ty) && "Invalid cast!");
2280  // Construct and return the appropriate CastInst subclass
2281  switch (op) {
2282  case Trunc: return new TruncInst (S, Ty, Name, InsertAtEnd);
2283  case ZExt: return new ZExtInst (S, Ty, Name, InsertAtEnd);
2284  case SExt: return new SExtInst (S, Ty, Name, InsertAtEnd);
2285  case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertAtEnd);
2286  case FPExt: return new FPExtInst (S, Ty, Name, InsertAtEnd);
2287  case UIToFP: return new UIToFPInst (S, Ty, Name, InsertAtEnd);
2288  case SIToFP: return new SIToFPInst (S, Ty, Name, InsertAtEnd);
2289  case FPToUI: return new FPToUIInst (S, Ty, Name, InsertAtEnd);
2290  case FPToSI: return new FPToSIInst (S, Ty, Name, InsertAtEnd);
2291  case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertAtEnd);
2292  case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertAtEnd);
2293  case BitCast: return new BitCastInst (S, Ty, Name, InsertAtEnd);
2294  case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertAtEnd);
2295  default: llvm_unreachable("Invalid opcode provided");
2296  }
2297 }
2298 
2300  const Twine &Name,
2301  Instruction *InsertBefore) {
2302  if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2303  return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
2304  return Create(Instruction::ZExt, S, Ty, Name, InsertBefore);
2305 }
2306 
2308  const Twine &Name,
2309  BasicBlock *InsertAtEnd) {
2310  if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2311  return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
2312  return Create(Instruction::ZExt, S, Ty, Name, InsertAtEnd);
2313 }
2314 
2316  const Twine &Name,
2317  Instruction *InsertBefore) {
2318  if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2319  return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
2320  return Create(Instruction::SExt, S, Ty, Name, InsertBefore);
2321 }
2322 
2324  const Twine &Name,
2325  BasicBlock *InsertAtEnd) {
2326  if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2327  return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
2328  return Create(Instruction::SExt, S, Ty, Name, InsertAtEnd);
2329 }
2330 
2332  const Twine &Name,
2333  Instruction *InsertBefore) {
2334  if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2335  return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
2336  return Create(Instruction::Trunc, S, Ty, Name, InsertBefore);
2337 }
2338 
2340  const Twine &Name,
2341  BasicBlock *InsertAtEnd) {
2342  if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2343  return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
2344  return Create(Instruction::Trunc, S, Ty, Name, InsertAtEnd);
2345 }
2346 
2348  const Twine &Name,
2349  BasicBlock *InsertAtEnd) {
2350  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2351  assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2352  "Invalid cast");
2353  assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
2354  assert((!Ty->isVectorTy() ||
2356  "Invalid cast");
2357 
2358  if (Ty->isIntOrIntVectorTy())
2359  return Create(Instruction::PtrToInt, S, Ty, Name, InsertAtEnd);
2360 
2361  return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertAtEnd);
2362 }
2363 
2364 /// @brief Create a BitCast or a PtrToInt cast instruction
2366  const Twine &Name,
2367  Instruction *InsertBefore) {
2368  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2369  assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2370  "Invalid cast");
2371  assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
2372  assert((!Ty->isVectorTy() ||
2374  "Invalid cast");
2375 
2376  if (Ty->isIntOrIntVectorTy())
2377  return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
2378 
2379  return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertBefore);
2380 }
2381 
2383  Value *S, Type *Ty,
2384  const Twine &Name,
2385  BasicBlock *InsertAtEnd) {
2386  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2387  assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2388 
2390  return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertAtEnd);
2391 
2392  return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
2393 }
2394 
2396  Value *S, Type *Ty,
2397  const Twine &Name,
2398  Instruction *InsertBefore) {
2399  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2400  assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2401 
2403  return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertBefore);
2404 
2405  return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
2406 }
2407 
2409  const Twine &Name,
2410  Instruction *InsertBefore) {
2411  if (S->getType()->isPointerTy() && Ty->isIntegerTy())
2412  return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
2413  if (S->getType()->isIntegerTy() && Ty->isPointerTy())
2414  return Create(Instruction::IntToPtr, S, Ty, Name, InsertBefore);
2415 
2416  return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
2417 }
2418 
2420  bool isSigned, const Twine &Name,
2421  Instruction *InsertBefore) {
2422  assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() &&
2423  "Invalid integer cast");
2424  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2425  unsigned DstBits = Ty->getScalarSizeInBits();
2426  Instruction::CastOps opcode =
2427  (SrcBits == DstBits ? Instruction::BitCast :
2428  (SrcBits > DstBits ? Instruction::Trunc :
2429  (isSigned ? Instruction::SExt : Instruction::ZExt)));
2430  return Create(opcode, C, Ty, Name, InsertBefore);
2431 }
2432 
2434  bool isSigned, const Twine &Name,
2435  BasicBlock *InsertAtEnd) {
2436  assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() &&
2437  "Invalid cast");
2438  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2439  unsigned DstBits = Ty->getScalarSizeInBits();
2440  Instruction::CastOps opcode =
2441  (SrcBits == DstBits ? Instruction::BitCast :
2442  (SrcBits > DstBits ? Instruction::Trunc :
2443  (isSigned ? Instruction::SExt : Instruction::ZExt)));
2444  return Create(opcode, C, Ty, Name, InsertAtEnd);
2445 }
2446 
2448  const Twine &Name,
2449  Instruction *InsertBefore) {
2450  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2451  "Invalid cast");
2452  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2453  unsigned DstBits = Ty->getScalarSizeInBits();
2454  Instruction::CastOps opcode =
2455  (SrcBits == DstBits ? Instruction::BitCast :
2456  (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
2457  return Create(opcode, C, Ty, Name, InsertBefore);
2458 }
2459 
2461  const Twine &Name,
2462  BasicBlock *InsertAtEnd) {
2463  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2464  "Invalid cast");
2465  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2466  unsigned DstBits = Ty->getScalarSizeInBits();
2467  Instruction::CastOps opcode =
2468  (SrcBits == DstBits ? Instruction::BitCast :
2469  (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
2470  return Create(opcode, C, Ty, Name, InsertAtEnd);
2471 }
2472 
2473 // Check whether it is valid to call getCastOpcode for these types.
2474 // This routine must be kept in sync with getCastOpcode.
2475 bool CastInst::isCastable(Type *SrcTy, Type *DestTy) {
2476  if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType())
2477  return false;
2478 
2479  if (SrcTy == DestTy)
2480  return true;
2481 
2482  if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy))
2483  if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy))
2484  if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) {
2485  // An element by element cast. Valid if casting the elements is valid.
2486  SrcTy = SrcVecTy->getElementType();
2487  DestTy = DestVecTy->getElementType();
2488  }
2489 
2490  // Get the bit sizes, we'll need these
2491  unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr
2492  unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
2493 
2494  // Run through the possibilities ...
2495  if (DestTy->isIntegerTy()) { // Casting to integral
2496  if (SrcTy->isIntegerTy()) // Casting from integral
2497  return true;
2498  if (SrcTy->isFloatingPointTy()) // Casting from floating pt
2499  return true;
2500  if (SrcTy->isVectorTy()) // Casting from vector
2501  return DestBits == SrcBits;
2502  // Casting from something else
2503  return SrcTy->isPointerTy();
2504  }
2505  if (DestTy->isFloatingPointTy()) { // Casting to floating pt
2506  if (SrcTy->isIntegerTy()) // Casting from integral
2507  return true;
2508  if (SrcTy->isFloatingPointTy()) // Casting from floating pt
2509  return true;
2510  if (SrcTy->isVectorTy()) // Casting from vector
2511  return DestBits == SrcBits;
2512  // Casting from something else
2513  return false;
2514  }
2515  if (DestTy->isVectorTy()) // Casting to vector
2516  return DestBits == SrcBits;
2517  if (DestTy->isPointerTy()) { // Casting to pointer
2518  if (SrcTy->isPointerTy()) // Casting from pointer
2519  return true;
2520  return SrcTy->isIntegerTy(); // Casting from integral
2521  }
2522  if (DestTy->isX86_MMXTy()) {
2523  if (SrcTy->isVectorTy())
2524  return DestBits == SrcBits; // 64-bit vector to MMX
2525  return false;
2526  } // Casting to something else
2527  return false;
2528 }
2529 
2530 bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
2531  if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType())
2532  return false;
2533 
2534  if (SrcTy == DestTy)
2535  return true;
2536 
2537  if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) {
2538  if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) {
2539  if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) {
2540  // An element by element cast. Valid if casting the elements is valid.
2541  SrcTy = SrcVecTy->getElementType();
2542  DestTy = DestVecTy->getElementType();
2543  }
2544  }
2545  }
2546 
2547  if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) {
2548  if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) {
2549  return SrcPtrTy->getAddressSpace() == DestPtrTy->getAddressSpace();
2550  }
2551  }
2552 
2553  unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr
2554  unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
2555 
2556  // Could still have vectors of pointers if the number of elements doesn't
2557  // match
2558  if (SrcBits == 0 || DestBits == 0)
2559  return false;
2560 
2561  if (SrcBits != DestBits)
2562  return false;
2563 
2564  if (DestTy->isX86_MMXTy() || SrcTy->isX86_MMXTy())
2565  return false;
2566 
2567  return true;
2568 }
2569 
2571  const DataLayout &DL) {
2572  if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
2573  if (auto *IntTy = dyn_cast<IntegerType>(DestTy))
2574  return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
2575  if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
2576  if (auto *IntTy = dyn_cast<IntegerType>(SrcTy))
2577  return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
2578 
2579  return isBitCastable(SrcTy, DestTy);
2580 }
2581 
2582 // Provide a way to get a "cast" where the cast opcode is inferred from the
2583 // types and size of the operand. This, basically, is a parallel of the
2584 // logic in the castIsValid function below. This axiom should hold:
2585 // castIsValid( getCastOpcode(Val, Ty), Val, Ty)
2586 // should not assert in castIsValid. In other words, this produces a "correct"
2587 // casting opcode for the arguments passed to it.
2588 // This routine must be kept in sync with isCastable.
2591  const Value *Src, bool SrcIsSigned, Type *DestTy, bool DestIsSigned) {
2592  Type *SrcTy = Src->getType();
2593 
2594  assert(SrcTy->isFirstClassType() && DestTy->isFirstClassType() &&
2595  "Only first class types are castable!");
2596 
2597  if (SrcTy == DestTy)
2598  return BitCast;
2599 
2600  // FIXME: Check address space sizes here
2601  if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy))
2602  if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy))
2603  if (SrcVecTy->getNumElements() == DestVecTy->getNumElements()) {
2604  // An element by element cast. Find the appropriate opcode based on the
2605  // element types.
2606  SrcTy = SrcVecTy->getElementType();
2607  DestTy = DestVecTy->getElementType();
2608  }
2609 
2610  // Get the bit sizes, we'll need these
2611  unsigned SrcBits = SrcTy->getPrimitiveSizeInBits(); // 0 for ptr
2612  unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
2613 
2614  // Run through the possibilities ...
2615  if (DestTy->isIntegerTy()) { // Casting to integral
2616  if (SrcTy->isIntegerTy()) { // Casting from integral
2617  if (DestBits < SrcBits)
2618  return Trunc; // int -> smaller int
2619  else if (DestBits > SrcBits) { // its an extension
2620  if (SrcIsSigned)
2621  return SExt; // signed -> SEXT
2622  else
2623  return ZExt; // unsigned -> ZEXT
2624  } else {
2625  return BitCast; // Same size, No-op cast
2626  }
2627  } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt
2628  if (DestIsSigned)
2629  return FPToSI; // FP -> sint
2630  else
2631  return FPToUI; // FP -> uint
2632  } else if (SrcTy->isVectorTy()) {
2633  assert(DestBits == SrcBits &&
2634  "Casting vector to integer of different width");
2635  return BitCast; // Same size, no-op cast
2636  } else {
2637  assert(SrcTy->isPointerTy() &&
2638  "Casting from a value that is not first-class type");
2639  return PtrToInt; // ptr -> int
2640  }
2641  } else if (DestTy->isFloatingPointTy()) { // Casting to floating pt
2642  if (SrcTy->isIntegerTy()) { // Casting from integral
2643  if (SrcIsSigned)
2644  return SIToFP; // sint -> FP
2645  else
2646  return UIToFP; // uint -> FP
2647  } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt
2648  if (DestBits < SrcBits) {
2649  return FPTrunc; // FP -> smaller FP
2650  } else if (DestBits > SrcBits) {
2651  return FPExt; // FP -> larger FP
2652  } else {
2653  return BitCast; // same size, no-op cast
2654  }
2655  } else if (SrcTy->isVectorTy()) {
2656  assert(DestBits == SrcBits &&
2657  "Casting vector to floating point of different width");
2658  return BitCast; // same size, no-op cast
2659  }
2660  llvm_unreachable("Casting pointer or non-first class to float");
2661  } else if (DestTy->isVectorTy()) {
2662  assert(DestBits == SrcBits &&
2663  "Illegal cast to vector (wrong type or size)");
2664  return BitCast;
2665  } else if (DestTy->isPointerTy()) {
2666  if (SrcTy->isPointerTy()) {
2667  if (DestTy->getPointerAddressSpace() != SrcTy->getPointerAddressSpace())
2668  return AddrSpaceCast;
2669  return BitCast; // ptr -> ptr
2670  } else if (SrcTy->isIntegerTy()) {
2671  return IntToPtr; // int -> ptr
2672  }
2673  llvm_unreachable("Casting pointer to other than pointer or int");
2674  } else if (DestTy->isX86_MMXTy()) {
2675  if (SrcTy->isVectorTy()) {
2676  assert(DestBits == SrcBits && "Casting vector of wrong width to X86_MMX");
2677  return BitCast; // 64-bit vector to MMX
2678  }
2679  llvm_unreachable("Illegal cast to X86_MMX");
2680  }
2681  llvm_unreachable("Casting to type that is not first-class");
2682 }
2683 
2684 //===----------------------------------------------------------------------===//
2685 // CastInst SubClass Constructors
2686 //===----------------------------------------------------------------------===//
2687 
2688 /// Check that the construction parameters for a CastInst are correct. This
2689 /// could be broken out into the separate constructors but it is useful to have
2690 /// it in one place and to eliminate the redundant code for getting the sizes
2691 /// of the types involved.
2692 bool
2694 
2695  // Check for type sanity on the arguments
2696  Type *SrcTy = S->getType();
2697 
2698  if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() ||
2699  SrcTy->isAggregateType() || DstTy->isAggregateType())
2700  return false;
2701 
2702  // Get the size of the types in bits, we'll need this later
2703  unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2704  unsigned DstBitSize = DstTy->getScalarSizeInBits();
2705 
2706  // If these are vector types, get the lengths of the vectors (using zero for
2707  // scalar types means that checking that vector lengths match also checks that
2708  // scalars are not being converted to vectors or vectors to scalars).
2709  unsigned SrcLength = SrcTy->isVectorTy() ?
2710  cast<VectorType>(SrcTy)->getNumElements() : 0;
2711  unsigned DstLength = DstTy->isVectorTy() ?
2712  cast<VectorType>(DstTy)->getNumElements() : 0;
2713 
2714  // Switch on the opcode provided
2715  switch (op) {
2716  default: return false; // This is an input error
2717  case Instruction::Trunc:
2718  return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
2719  SrcLength == DstLength && SrcBitSize > DstBitSize;
2720  case Instruction::ZExt:
2721  return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
2722  SrcLength == DstLength && SrcBitSize < DstBitSize;
2723  case Instruction::SExt:
2724  return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
2725  SrcLength == DstLength && SrcBitSize < DstBitSize;
2726  case Instruction::FPTrunc:
2727  return SrcTy->isFPOrFPVectorTy() && DstTy->isFPOrFPVectorTy() &&
2728  SrcLength == DstLength && SrcBitSize > DstBitSize;
2729  case Instruction::FPExt:
2730  return SrcTy->isFPOrFPVectorTy() && DstTy->isFPOrFPVectorTy() &&
2731  SrcLength == DstLength && SrcBitSize < DstBitSize;
2732  case Instruction::UIToFP:
2733  case Instruction::SIToFP:
2734  return SrcTy->isIntOrIntVectorTy() && DstTy->isFPOrFPVectorTy() &&
2735  SrcLength == DstLength;
2736  case Instruction::FPToUI:
2737  case Instruction::FPToSI:
2738  return SrcTy->isFPOrFPVectorTy() && DstTy->isIntOrIntVectorTy() &&
2739  SrcLength == DstLength;
2740  case Instruction::PtrToInt:
2741  if (isa<VectorType>(SrcTy) != isa<VectorType>(DstTy))
2742  return false;
2743  if (VectorType *VT = dyn_cast<VectorType>(SrcTy))
2744  if (VT->getNumElements() != cast<VectorType>(DstTy)->getNumElements())
2745  return false;
2746  return SrcTy->getScalarType()->isPointerTy() &&
2747  DstTy->getScalarType()->isIntegerTy();
2748  case Instruction::IntToPtr:
2749  if (isa<VectorType>(SrcTy) != isa<VectorType>(DstTy))
2750  return false;
2751  if (VectorType *VT = dyn_cast<VectorType>(SrcTy))
2752  if (VT->getNumElements() != cast<VectorType>(DstTy)->getNumElements())
2753  return false;
2754  return SrcTy->getScalarType()->isIntegerTy() &&
2755  DstTy->getScalarType()->isPointerTy();
2756  case Instruction::BitCast: {
2757  PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
2758  PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
2759 
2760  // BitCast implies a no-op cast of type only. No bits change.
2761  // However, you can't cast pointers to anything but pointers.
2762  if (!SrcPtrTy != !DstPtrTy)
2763  return false;
2764 
2765  // For non-pointer cases, the cast is okay if the source and destination bit
2766  // widths are identical.
2767  if (!SrcPtrTy)
2768  return SrcTy->getPrimitiveSizeInBits() == DstTy->getPrimitiveSizeInBits();
2769 
2770  // If both are pointers then the address spaces must match.
2771  if (SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace())
2772  return false;
2773 
2774  // A vector of pointers must have the same number of elements.
2775  if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) {
2776  if (VectorType *DstVecTy = dyn_cast<VectorType>(DstTy))
2777  return (SrcVecTy->getNumElements() == DstVecTy->getNumElements());
2778 
2779  return false;
2780  }
2781 
2782  return true;
2783  }
2784  case Instruction::AddrSpaceCast: {
2785  PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
2786  if (!SrcPtrTy)
2787  return false;
2788 
2789  PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
2790  if (!DstPtrTy)
2791  return false;
2792 
2793  if (SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace())
2794  return false;
2795 
2796  if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) {
2797  if (VectorType *DstVecTy = dyn_cast<VectorType>(DstTy))
2798  return (SrcVecTy->getNumElements() == DstVecTy->getNumElements());
2799 
2800  return false;
2801  }
2802 
2803  return true;
2804  }
2805  }
2806 }
2807 
2809  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2810 ) : CastInst(Ty, Trunc, S, Name, InsertBefore) {
2811  assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
2812 }
2813 
2815  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2816 ) : CastInst(Ty, Trunc, S, Name, InsertAtEnd) {
2817  assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
2818 }
2819 
2821  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2822 ) : CastInst(Ty, ZExt, S, Name, InsertBefore) {
2823  assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
2824 }
2825 
2827  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2828 ) : CastInst(Ty, ZExt, S, Name, InsertAtEnd) {
2829  assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
2830 }
2832  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2833 ) : CastInst(Ty, SExt, S, Name, InsertBefore) {
2834  assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
2835 }
2836 
2838  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2839 ) : CastInst(Ty, SExt, S, Name, InsertAtEnd) {
2840  assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
2841 }
2842 
2844  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2845 ) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
2846  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
2847 }
2848 
2850  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2851 ) : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) {
2852  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
2853 }
2854 
2856  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2857 ) : CastInst(Ty, FPExt, S, Name, InsertBefore) {
2858  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
2859 }
2860 
2862  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2863 ) : CastInst(Ty, FPExt, S, Name, InsertAtEnd) {
2864  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
2865 }
2866 
2868  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2869 ) : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
2870  assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
2871 }
2872 
2874  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2875 ) : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) {
2876  assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
2877 }
2878 
2880  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2881 ) : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
2882  assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
2883 }
2884 
2886  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2887 ) : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) {
2888  assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
2889 }
2890 
2892  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2893 ) : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
2894  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
2895 }
2896 
2898  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2899 ) : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) {
2900  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
2901 }
2902 
2904  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2905 ) : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
2906  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
2907 }
2908 
2910  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2911 ) : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) {
2912  assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
2913 }
2914 
2916  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2917 ) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
2918  assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
2919 }
2920 
2922  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2923 ) : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) {
2924  assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
2925 }
2926 
2928  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2929 ) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
2930  assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
2931 }
2932 
2934  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2935 ) : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) {
2936  assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
2937 }
2938 
2940  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2941 ) : CastInst(Ty, BitCast, S, Name, InsertBefore) {
2942  assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
2943 }
2944 
2946  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2947 ) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) {
2948  assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
2949 }
2950 
2952  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
2953 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
2954  assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
2955 }
2956 
2958  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
2959 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) {
2960  assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
2961 }
2962 
2963 //===----------------------------------------------------------------------===//
2964 // CmpInst Classes
2965 //===----------------------------------------------------------------------===//
2966 
2968 
2969 CmpInst::CmpInst(Type *ty, OtherOps op, unsigned short predicate,
2970  Value *LHS, Value *RHS, const Twine &Name,
2971  Instruction *InsertBefore)
2972  : Instruction(ty, op,
2973  OperandTraits<CmpInst>::op_begin(this),
2974  OperandTraits<CmpInst>::operands(this),
2975  InsertBefore) {
2976  Op<0>() = LHS;
2977  Op<1>() = RHS;
2978  setPredicate((Predicate)predicate);
2979  setName(Name);
2980 }
2981 
2982 CmpInst::CmpInst(Type *ty, OtherOps op, unsigned short predicate,
2983  Value *LHS, Value *RHS, const Twine &Name,
2984  BasicBlock *InsertAtEnd)
2985  : Instruction(ty, op,
2986  OperandTraits<CmpInst>::op_begin(this),
2987  OperandTraits<CmpInst>::operands(this),
2988  InsertAtEnd) {
2989  Op<0>() = LHS;
2990  Op<1>() = RHS;
2991  setPredicate((Predicate)predicate);
2992  setName(Name);
2993 }
2994 
2995 CmpInst *
2996 CmpInst::Create(OtherOps Op, unsigned short predicate,
2997  Value *S1, Value *S2,
2998  const Twine &Name, Instruction *InsertBefore) {
2999  if (Op == Instruction::ICmp) {
3000  if (InsertBefore)
3001  return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate),
3002  S1, S2, Name);
3003  else
3004  return new ICmpInst(CmpInst::Predicate(predicate),
3005  S1, S2, Name);
3006  }
3007 
3008  if (InsertBefore)
3009  return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate),
3010  S1, S2, Name);
3011  else
3012  return new FCmpInst(CmpInst::Predicate(predicate),
3013  S1, S2, Name);
3014 }
3015 
3016 CmpInst *
3017 CmpInst::Create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2,
3018  const Twine &Name, BasicBlock *InsertAtEnd) {
3019  if (Op == Instruction::ICmp) {
3020  return new ICmpInst(*InsertAtEnd, CmpInst::Predicate(predicate),
3021  S1, S2, Name);
3022  }
3023  return new FCmpInst(*InsertAtEnd, CmpInst::Predicate(predicate),
3024  S1, S2, Name);
3025 }
3026 
3028  if (ICmpInst *IC = dyn_cast<ICmpInst>(this))
3029  IC->swapOperands();
3030  else
3031  cast<FCmpInst>(this)->swapOperands();
3032 }
3033 
3035  if (const ICmpInst *IC = dyn_cast<ICmpInst>(this))
3036  return IC->isCommutative();
3037  return cast<FCmpInst>(this)->isCommutative();
3038 }
3039 
3040 bool CmpInst::isEquality() const {
3041  if (const ICmpInst *IC = dyn_cast<ICmpInst>(this))
3042  return IC->isEquality();
3043  return cast<FCmpInst>(this)->isEquality();
3044 }
3045 
3046 
3048  switch (pred) {
3049  default: llvm_unreachable("Unknown cmp predicate!");
3050  case ICMP_EQ: return ICMP_NE;
3051  case ICMP_NE: return ICMP_EQ;
3052  case ICMP_UGT: return ICMP_ULE;
3053  case ICMP_ULT: return ICMP_UGE;
3054  case ICMP_UGE: return ICMP_ULT;
3055  case ICMP_ULE: return ICMP_UGT;
3056  case ICMP_SGT: return ICMP_SLE;
3057  case ICMP_SLT: return ICMP_SGE;
3058  case ICMP_SGE: return ICMP_SLT;
3059  case ICMP_SLE: return ICMP_SGT;
3060 
3061  case FCMP_OEQ: return FCMP_UNE;
3062  case FCMP_ONE: return FCMP_UEQ;
3063  case FCMP_OGT: return FCMP_ULE;
3064  case FCMP_OLT: return FCMP_UGE;
3065  case FCMP_OGE: return FCMP_ULT;
3066  case FCMP_OLE: return FCMP_UGT;
3067  case FCMP_UEQ: return FCMP_ONE;
3068  case FCMP_UNE: return FCMP_OEQ;
3069  case FCMP_UGT: return FCMP_OLE;
3070  case FCMP_ULT: return FCMP_OGE;
3071  case FCMP_UGE: return FCMP_OLT;
3072  case FCMP_ULE: return FCMP_OGT;
3073  case FCMP_ORD: return FCMP_UNO;
3074  case FCMP_UNO: return FCMP_ORD;
3075  case FCMP_TRUE: return FCMP_FALSE;
3076  case FCMP_FALSE: return FCMP_TRUE;
3077  }
3078 }
3079 
3081  switch (pred) {
3082  default: llvm_unreachable("Unknown icmp predicate!");
3083  case ICMP_EQ: case ICMP_NE:
3084  case ICMP_SGT: case ICMP_SLT: case ICMP_SGE: case ICMP_SLE:
3085  return pred;
3086  case ICMP_UGT: return ICMP_SGT;
3087  case ICMP_ULT: return ICMP_SLT;
3088  case ICMP_UGE: return ICMP_SGE;
3089  case ICMP_ULE: return ICMP_SLE;
3090  }
3091 }
3092 
3094  switch (pred) {
3095  default: llvm_unreachable("Unknown icmp predicate!");
3096  case ICMP_EQ: case ICMP_NE:
3097  case ICMP_UGT: case ICMP_ULT: case ICMP_UGE: case ICMP_ULE:
3098  return pred;
3099  case ICMP_SGT: return ICMP_UGT;
3100  case ICMP_SLT: return ICMP_ULT;
3101  case ICMP_SGE: return ICMP_UGE;
3102  case ICMP_SLE: return ICMP_ULE;
3103  }
3104 }
3105 
3106 /// Initialize a set of values that all satisfy the condition with C.
3107 ///
3110  APInt Lower(C);
3111  APInt Upper(C);
3112  uint32_t BitWidth = C.getBitWidth();
3113  switch (pred) {
3114  default: llvm_unreachable("Invalid ICmp opcode to ConstantRange ctor!");
3115  case ICmpInst::ICMP_EQ: ++Upper; break;
3116  case ICmpInst::ICMP_NE: ++Lower; break;
3117  case ICmpInst::ICMP_ULT:
3118  Lower = APInt::getMinValue(BitWidth);
3119  // Check for an empty-set condition.
3120  if (Lower == Upper)
3121  return ConstantRange(BitWidth, /*isFullSet=*/false);
3122  break;
3123  case ICmpInst::ICMP_SLT:
3124  Lower = APInt::getSignedMinValue(BitWidth);
3125  // Check for an empty-set condition.
3126  if (Lower == Upper)
3127  return ConstantRange(BitWidth, /*isFullSet=*/false);
3128  break;
3129  case ICmpInst::ICMP_UGT:
3130  ++Lower; Upper = APInt::getMinValue(BitWidth); // Min = Next(Max)
3131  // Check for an empty-set condition.
3132  if (Lower == Upper)
3133  return ConstantRange(BitWidth, /*isFullSet=*/false);
3134  break;
3135  case ICmpInst::ICMP_SGT:
3136  ++Lower; Upper = APInt::getSignedMinValue(BitWidth); // Min = Next(Max)
3137  // Check for an empty-set condition.
3138  if (Lower == Upper)
3139  return ConstantRange(BitWidth, /*isFullSet=*/false);
3140  break;
3141  case ICmpInst::ICMP_ULE:
3142  Lower = APInt::getMinValue(BitWidth); ++Upper;
3143  // Check for a full-set condition.
3144  if (Lower == Upper)
3145  return ConstantRange(BitWidth, /*isFullSet=*/true);
3146  break;
3147  case ICmpInst::ICMP_SLE:
3148  Lower = APInt::getSignedMinValue(BitWidth); ++Upper;
3149  // Check for a full-set condition.
3150  if (Lower == Upper)
3151  return ConstantRange(BitWidth, /*isFullSet=*/true);
3152  break;
3153  case ICmpInst::ICMP_UGE:
3154  Upper = APInt::getMinValue(BitWidth); // Min = Next(Max)
3155  // Check for a full-set condition.
3156  if (Lower == Upper)
3157  return ConstantRange(BitWidth, /*isFullSet=*/true);
3158  break;
3159  case ICmpInst::ICMP_SGE:
3160  Upper = APInt::getSignedMinValue(BitWidth); // Min = Next(Max)
3161  // Check for a full-set condition.
3162  if (Lower == Upper)
3163  return ConstantRange(BitWidth, /*isFullSet=*/true);
3164  break;
3165  }
3166  return ConstantRange(Lower, Upper);
3167 }
3168 
3170  switch (pred) {
3171  default: llvm_unreachable("Unknown cmp predicate!");
3172  case ICMP_EQ: case ICMP_NE:
3173  return pred;
3174  case ICMP_SGT: return ICMP_SLT;
3175  case ICMP_SLT: return ICMP_SGT;
3176  case ICMP_SGE: return ICMP_SLE;
3177  case ICMP_SLE: return ICMP_SGE;
3178  case ICMP_UGT: return ICMP_ULT;
3179  case ICMP_ULT: return ICMP_UGT;
3180  case ICMP_UGE: return ICMP_ULE;
3181  case ICMP_ULE: return ICMP_UGE;
3182 
3183  case FCMP_FALSE: case FCMP_TRUE:
3184  case FCMP_OEQ: case FCMP_ONE:
3185  case FCMP_UEQ: case FCMP_UNE:
3186  case FCMP_ORD: case FCMP_UNO:
3187  return pred;
3188  case FCMP_OGT: return FCMP_OLT;
3189  case FCMP_OLT: return FCMP_OGT;
3190  case FCMP_OGE: return FCMP_OLE;
3191  case FCMP_OLE: return FCMP_OGE;
3192  case FCMP_UGT: return FCMP_ULT;
3193  case FCMP_ULT: return FCMP_UGT;
3194  case FCMP_UGE: return FCMP_ULE;
3195  case FCMP_ULE: return FCMP_UGE;
3196  }
3197 }
3198 
3199 bool CmpInst::isUnsigned(unsigned short predicate) {
3200  switch (predicate) {
3201  default: return false;
3203  case ICmpInst::ICMP_UGE: return true;
3204  }
3205 }
3206 
3207 bool CmpInst::isSigned(unsigned short predicate) {
3208  switch (predicate) {
3209  default: return false;
3211  case ICmpInst::ICMP_SGE: return true;
3212  }
3213 }
3214 
3215 bool CmpInst::isOrdered(unsigned short predicate) {
3216  switch (predicate) {
3217  default: return false;
3220  case FCmpInst::FCMP_ORD: return true;
3221  }
3222 }
3223 
3224 bool CmpInst::isUnordered(unsigned short predicate) {
3225  switch (predicate) {
3226  default: return false;
3229  case FCmpInst::FCMP_UNO: return true;
3230  }
3231 }
3232 
3233 bool CmpInst::isTrueWhenEqual(unsigned short predicate) {
3234  switch(predicate) {
3235  default: return false;
3236  case ICMP_EQ: case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE:
3237  case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true;
3238  }
3239 }
3240 
3241 bool CmpInst::isFalseWhenEqual(unsigned short predicate) {
3242  switch(predicate) {
3243  case ICMP_NE: case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT:
3244  case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true;
3245  default: return false;
3246  }
3247 }
3248 
3249 
3250 //===----------------------------------------------------------------------===//
3251 // SwitchInst Implementation
3252 //===----------------------------------------------------------------------===//
3253 
3254 void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) {
3255  assert(Value && Default && NumReserved);
3256  ReservedSpace = NumReserved;
3258  allocHungoffUses(ReservedSpace);
3259 
3260  Op<0>() = Value;
3261  Op<1>() = Default;
3262 }
3263 
3264 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
3265 /// switch on and a default destination. The number of additional cases can
3266 /// be specified here to make memory allocation more efficient. This
3267 /// constructor can also autoinsert before another instruction.
3268 SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
3269  Instruction *InsertBefore)
3270  : TerminatorInst(Type::getVoidTy(Value->getContext()), Instruction::Switch,
3271  nullptr, 0, InsertBefore) {
3272  init(Value, Default, 2+NumCases*2);
3273 }
3274 
3275 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
3276 /// switch on and a default destination. The number of additional cases can
3277 /// be specified here to make memory allocation more efficient. This
3278 /// constructor also autoinserts at the end of the specified BasicBlock.
3279 SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
3280  BasicBlock *InsertAtEnd)
3281  : TerminatorInst(Type::getVoidTy(Value->getContext()), Instruction::Switch,
3282  nullptr, 0, InsertAtEnd) {
3283  init(Value, Default, 2+NumCases*2);
3284 }
3285 
3286 SwitchInst::SwitchInst(const SwitchInst &SI)
3287  : TerminatorInst(SI.getType(), Instruction::Switch, nullptr, 0) {
3288  init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands());
3290  Use *OL = getOperandList();
3291  const Use *InOL = SI.getOperandList();
3292  for (unsigned i = 2, E = SI.getNumOperands(); i != E; i += 2) {
3293  OL[i] = InOL[i];
3294  OL[i+1] = InOL[i+1];
3295  }
3297 }
3298 
3299 
3300 /// addCase - Add an entry to the switch instruction...
3301 ///
3303  unsigned NewCaseIdx = getNumCases();
3304  unsigned OpNo = getNumOperands();
3305  if (OpNo+2 > ReservedSpace)
3306  growOperands(); // Get more space!
3307  // Initialize some new operands.
3308  assert(OpNo+1 < ReservedSpace && "Growing didn't work!");
3309  setNumHungOffUseOperands(OpNo+2);
3310  CaseIt Case(this, NewCaseIdx);
3311  Case.setValue(OnVal);
3312  Case.setSuccessor(Dest);
3313 }
3314 
3315 /// removeCase - This method removes the specified case and its successor
3316 /// from the switch instruction.
3318  unsigned idx = i.getCaseIndex();
3319 
3320  assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!");
3321 
3322  unsigned NumOps = getNumOperands();
3323  Use *OL = getOperandList();
3324 
3325  // Overwrite this case with the end of the list.
3326  if (2 + (idx + 1) * 2 != NumOps) {
3327  OL[2 + idx * 2] = OL[NumOps - 2];
3328  OL[2 + idx * 2 + 1] = OL[NumOps - 1];
3329  }
3330 
3331  // Nuke the last value.
3332  OL[NumOps-2].set(nullptr);
3333  OL[NumOps-2+1].set(nullptr);
3334  setNumHungOffUseOperands(NumOps-2);
3335 }
3336 
3337 /// growOperands - grow operands - This grows the operand list in response
3338 /// to a push_back style of operation. This grows the number of ops by 3 times.
3339 ///
3340 void SwitchInst::growOperands() {
3341  unsigned e = getNumOperands();
3342  unsigned NumOps = e*3;
3343 
3344  ReservedSpace = NumOps;
3345  growHungoffUses(ReservedSpace);
3346 }
3347 
3348 
3349 BasicBlock *SwitchInst::getSuccessorV(unsigned idx) const {
3350  return getSuccessor(idx);
3351 }
3352 unsigned SwitchInst::getNumSuccessorsV() const {
3353  return getNumSuccessors();
3354 }
3355 void SwitchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
3356  setSuccessor(idx, B);
3357 }
3358 
3359 //===----------------------------------------------------------------------===//
3360 // IndirectBrInst Implementation
3361 //===----------------------------------------------------------------------===//
3362 
3363 void IndirectBrInst::init(Value *Address, unsigned NumDests) {
3364  assert(Address && Address->getType()->isPointerTy() &&
3365  "Address of indirectbr must be a pointer");
3366  ReservedSpace = 1+NumDests;
3368  allocHungoffUses(ReservedSpace);
3369 
3370  Op<0>() = Address;
3371 }
3372 
3373 
3374 /// growOperands - grow operands - This grows the operand list in response
3375 /// to a push_back style of operation. This grows the number of ops by 2 times.
3376 ///
3377 void IndirectBrInst::growOperands() {
3378  unsigned e = getNumOperands();
3379  unsigned NumOps = e*2;
3380 
3381  ReservedSpace = NumOps;
3382  growHungoffUses(ReservedSpace);
3383 }
3384 
3385 IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
3386  Instruction *InsertBefore)
3387 : TerminatorInst(Type::getVoidTy(Address->getContext()),Instruction::IndirectBr,
3388  nullptr, 0, InsertBefore) {
3389  init(Address, NumCases);
3390 }
3391 
3392 IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
3393  BasicBlock *InsertAtEnd)
3394 : TerminatorInst(Type::getVoidTy(Address->getContext()),Instruction::IndirectBr,
3395  nullptr, 0, InsertAtEnd) {
3396  init(Address, NumCases);
3397 }
3398 
3399 IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI)
3400  : TerminatorInst(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr,
3401  nullptr, IBI.getNumOperands()) {
3403  Use *OL = getOperandList();
3404  const Use *InOL = IBI.getOperandList();
3405  for (unsigned i = 0, E = IBI.getNumOperands(); i != E; ++i)
3406  OL[i] = InOL[i];
3408 }
3409 
3410 /// addDestination - Add a destination.
3411 ///
3413  unsigned OpNo = getNumOperands();
3414  if (OpNo+1 > ReservedSpace)
3415  growOperands(); // Get more space!
3416  // Initialize some new operands.
3417  assert(OpNo < ReservedSpace && "Growing didn't work!");
3418  setNumHungOffUseOperands(OpNo+1);
3419  getOperandList()[OpNo] = DestBB;
3420 }
3421 
3422 /// removeDestination - This method removes the specified successor from the
3423 /// indirectbr instruction.
3425  assert(idx < getNumOperands()-1 && "Successor index out of range!");
3426 
3427  unsigned NumOps = getNumOperands();
3428  Use *OL = getOperandList();
3429 
3430  // Replace this value with the last one.
3431  OL[idx+1] = OL[NumOps-1];
3432 
3433  // Nuke the last value.
3434  OL[NumOps-1].set(nullptr);
3435  setNumHungOffUseOperands(NumOps-1);
3436 }
3437 
3438 BasicBlock *IndirectBrInst::getSuccessorV(unsigned idx) const {
3439  return getSuccessor(idx);
3440 }
3441 unsigned IndirectBrInst::getNumSuccessorsV() const {
3442  return getNumSuccessors();
3443 }
3444 void IndirectBrInst::setSuccessorV(unsigned idx, BasicBlock *B) {
3445  setSuccessor(idx, B);
3446 }
3447 
3448 //===----------------------------------------------------------------------===//
3449 // cloneImpl() implementations
3450 //===----------------------------------------------------------------------===//
3451 
3452 // Define these methods here so vtables don't get emitted into every translation
3453 // unit that uses these classes.
3454 
3456  return new (getNumOperands()) GetElementPtrInst(*this);
3457 }
3458 
3460  return Create(getOpcode(), Op<0>(), Op<1>());
3461 }
3462 
3464  return new FCmpInst(getPredicate(), Op<0>(), Op<1>());
3465 }
3466 
3468  return new ICmpInst(getPredicate(), Op<0>(), Op<1>());
3469 }
3470 
3472  return new ExtractValueInst(*this);
3473 }
3474 
3476  return new InsertValueInst(*this);
3477 }
3478 
3480  AllocaInst *Result = new AllocaInst(getAllocatedType(),
3481  (Value *)getOperand(0), getAlignment());
3483  return Result;
3484 }
3485 
3487  return new LoadInst(getOperand(0), Twine(), isVolatile(),
3489 }
3490 
3492  return new StoreInst(getOperand(0), getOperand(1), isVolatile(),
3494 
3495 }
3496 
3498  AtomicCmpXchgInst *Result =
3501  getSynchScope());
3502  Result->setVolatile(isVolatile());
3503  Result->setWeak(isWeak());
3504  return Result;
3505 }
3506 
3508  AtomicRMWInst *Result =
3510  getOrdering(), getSynchScope());
3511  Result->setVolatile(isVolatile());
3512  return Result;
3513 }
3514 
3516  return new FenceInst(getContext(), getOrdering(), getSynchScope());
3517 }
3518 
3520  return new TruncInst(getOperand(0), getType());
3521 }
3522 
3524  return new ZExtInst(getOperand(0), getType());
3525 }
3526 
3528  return new SExtInst(getOperand(0), getType());
3529 }
3530 
3532  return new FPTruncInst(getOperand(0), getType());
3533 }
3534 
3536  return new FPExtInst(getOperand(0), getType());
3537 }
3538 
3540  return new UIToFPInst(getOperand(0), getType());
3541 }
3542 
3544  return new SIToFPInst(getOperand(0), getType());
3545 }
3546 
3548  return new FPToUIInst(getOperand(0), getType());
3549 }
3550 
3552  return new FPToSIInst(getOperand(0), getType());
3553 }
3554 
3556  return new PtrToIntInst(getOperand(0), getType());
3557 }
3558 
3560  return new IntToPtrInst(getOperand(0), getType());
3561 }
3562 
3564  return new BitCastInst(getOperand(0), getType());
3565 }
3566 
3568  return new AddrSpaceCastInst(getOperand(0), getType());
3569 }
3570 
3572  return new(getNumOperands()) CallInst(*this);
3573 }
3574 
3577 }
3578 
3580  return new VAArgInst(getOperand(0), getType());
3581 }
3582 
3585 }
3586 
3589 }
3590 
3592  return new ShuffleVectorInst(getOperand(0), getOperand(1), getOperand(2));
3593 }
3594 
3595 PHINode *PHINode::cloneImpl() const { return new PHINode(*this); }
3596 
3598  return new LandingPadInst(*this);
3599 }
3600 
3602  return new(getNumOperands()) ReturnInst(*this);
3603 }
3604 
3606  return new(getNumOperands()) BranchInst(*this);
3607 }
3608 
3609 SwitchInst *SwitchInst::cloneImpl() const { return new SwitchInst(*this); }
3610 
3612  return new IndirectBrInst(*this);
3613 }
3614 
3616  return new(getNumOperands()) InvokeInst(*this);
3617 }
3618 
3619 ResumeInst *ResumeInst::cloneImpl() const { return new (1) ResumeInst(*this); }
3620 
3622  LLVMContext &Context = getContext();
3623  return new UnreachableInst(Context);
3624 }
static int getMaskValue(Constant *Mask, unsigned i)
getMaskValue - Return the index from the shuffle mask for the specified output result.
static Instruction * createMalloc(Instruction *InsertBefore, BasicBlock *InsertAtEnd, Type *IntPtrTy, Type *AllocTy, Value *AllocSize, Value *ArraySize, Function *MallocF, const Twine &Name)
BasicBlock * getSuccessor(unsigned i) const
void removeAttribute(unsigned i, Attribute attr)
removeAttribute - removes the attribute from the list of attributes.
ReturnInst - Return a value (possibly void), from a function.
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
void setAttributes(const AttributeSet &Attrs)
setAttributes - Set the parameter attributes for this invoke.
void push_back(const T &Elt)
Definition: SmallVector.h:222
AllocaInst(Type *Ty, Value *ArraySize=nullptr, const Twine &Name="", Instruction *InsertBefore=nullptr)
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
AtomicOrdering getFailureOrdering() const
Returns the ordering constraint on this cmpxchg.
Definition: Instructions.h:597
AtomicRMWInst * cloneImpl() const
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.
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:649
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:679
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:236
ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate...
static bool IsConstantOne(Value *val)
IsConstantOne - Return true only if val is constant int 1.
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
static const Value * getFNegArgument(const Value *BinOp)
void init(BinaryOps iType)
LandingPadInst * cloneImpl() const
bool isVolatile() const
isVolatile - Return true if this is a store to a volatile memory location.
Definition: Instructions.h:351
SynchronizationScope getSynchScope() const
Definition: Instructions.h:383
void swapSuccessors()
Swap the successors of this branch instruction.
void allocHungoffUses(unsigned N)
static bool isValidOperands(const Value *Vec, const Value *NewElt, const Value *Idx)
isValidOperands - Return true if an insertelement instruction can be formed with the specified operan...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
unsigned getNumParams() const
getNumParams - Return the number of fixed parameters this function type requires. ...
Definition: DerivedTypes.h:136
void setOrdering(AtomicOrdering Ordering)
Set the ordering constraint on this RMW.
Definition: Instructions.h:753
void setAlignment(unsigned Align)
static CastInst * CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=0)
Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
AtomicOrdering getSuccessOrdering() const
Returns the ordering constraint on this cmpxchg.
Definition: Instructions.h:592
FenceInst - an instruction for ordering other memory operations.
Definition: Instructions.h:445
ExtractElementInst * cloneImpl() const
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
PtrToIntInst * cloneImpl() const
Clone an identical PtrToIntInst.
void setSynchScope(SynchronizationScope xthread)
Specify whether this fence orders other operations with respect to all concurrently executing threads...
Definition: Instructions.h:487
This class represents zero extension of integer types.
unsigned getNumOperands() const
Definition: User.h:138
unsigned getNumSuccessors() const
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
Definition: DataLayout.cpp:602
void setSuccessor(BasicBlock *S)
Sets the new successor for current case.
static bool isOrdered(unsigned short predicate)
Determine if the predicate is an ordered operation.
void addCase(ConstantInt *OnVal, BasicBlock *Dest)
addCase - Add an entry to the switch instruction...
iterator end() const
Definition: ArrayRef.h:123
CallInst - This class represents a function call, abstracting a target machine's calling convention...
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:783
bool indexValid(const Value *V) const
Definition: Type.cpp:652
Function * getCalledFunction() const
getCalledFunction - Return the function called, or null if this is an indirect function invocation...
unsigned less or equal
Definition: InstrTypes.h:723
unsigned less than
Definition: InstrTypes.h:722
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:826
void setVolatile(bool V)
setVolatile - Specify whether this is a volatile cmpxchg.
Definition: Instructions.h:550
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:703
ShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors.
IndirectBrInst * cloneImpl() const
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:713
bool isPtrOrPtrVectorTy() const
isPtrOrPtrVectorTy - Return true if this is a pointer type or a vector of pointer types...
Definition: Type.h:222
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
void setSuccessor(unsigned i, BasicBlock *NewSucc)
Metadata node.
Definition: Metadata.h:740
F(f)
This class represents a sign extension of integer types.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:472
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
Definition: Instructions.h:674
static Instruction * CreateFree(Value *Source, Instruction *InsertBefore)
CreateFree - Generate the IR for a call to the builtin free function.
BranchInst * cloneImpl() const
#define op(i)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: Type.cpp:216
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:956
SExtInst * cloneImpl() const
Clone an identical SExtInst.
void setSynchScope(SynchronizationScope SynchScope)
Specify whether this cmpxchg is atomic and orders other operations with respect to all concurrently e...
Definition: Instructions.h:586
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
BinaryOperator * cloneImpl() const
op_iterator op_begin()
Definition: User.h:183
bool isEquality() const
This is just a convenience that dispatches to the subclasses.
static LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...
Type * getPointerElementType() const
Definition: Type.h:366
UnreachableInst * cloneImpl() const
FPExtInst * cloneImpl() const
Clone an identical FPExtInst.
void setVolatile(bool V)
setVolatile - Specify whether this is a volatile RMW or not.
Definition: Instructions.h:744
static bool isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, const DataLayout &DL)
Check whether a bitcast, inttoptr, or ptrtoint cast between these types is valid and a no-op...
block_iterator block_end()
void setCallingConv(CallingConv::ID CC)
bool swapOperands()
Exchange the two operands to this instruction.
bool isArrayAllocation() const
isArrayAllocation - Return true if there is an allocation size parameter to the allocation instructio...
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:708
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:707
static const Value * getNegArgument(const Value *BinOp)
Helper functions to extract the unary argument of a NEG, FNEG or NOT operation implemented via Sub...
This class represents a conversion between pointers from one address space to another.
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1674
static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy)
This method can be used to determine if a cast from S to DstTy using Opcode op is valid or not...
void push_back(NodeTy *val)
Definition: ilist.h:554
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
removeIncomingValue - Remove an incoming value.
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
getIndexedType - Returns the type of the element that would be extracted with an extractvalue instruc...
unsigned getSubclassDataFromInstruction() const
Definition: Instruction.h:504
SelectInst - This class represents the LLVM 'select' instruction.
IntToPtrInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:389
CallInst * cloneImpl() const
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#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
void growHungoffUses(unsigned N, bool IsPhi=false)
Grow the number of hung off uses.
Definition: User.cpp:63
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
void setOrdering(AtomicOrdering Ordering)
Set the ordering constraint on this fence.
Definition: Instructions.h:475
void setIsInBounds(bool b=true)
setIsInBounds - Set or clear the inbounds flag on this GEP instruction.
PtrToIntInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
Instruction * getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:165
static bool isNoopCast(Instruction::CastOps Opcode, Type *SrcTy, Type *DstTy, Type *IntPtrTy)
A no-op cast is one that can be effected without changing any bits.
UIToFPInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:704
FCmpInst * cloneImpl() const
Clone an identical FCmpInst.
bool isSized(SmallPtrSetImpl< const Type * > *Visited=nullptr) const
isSized - Return true if it makes sense to take the size of this type.
Definition: Type.h:268
SynchronizationScope
Definition: Instructions.h:49
AttributeSet addDereferenceableAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given index.
Definition: Attributes.cpp:907
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
FPToUIInst * cloneImpl() const
Clone an identical FPToUIInst.
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
static const unsigned MaximumAlignment
Definition: Value.h:463
LandingPadInst * getLandingPadInst() const
getLandingPadInst - Get the landingpad instruction from the landing pad block (the unwind destination...
#define false
Definition: ConvertUTF.c:65
block_iterator block_begin()
unsigned getNumSuccessors() const
SynchronizationScope getSynchScope() const
Definition: Instructions.h:261
This class represents a cast from a pointer to an integer.
Use * getOperandList()
Definition: User.h:112
AtomicOrdering
Definition: Instructions.h:38
static bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
isValidOperands - Return true if a shufflevector instruction can be formed with the specified operand...
UIToFPInst * cloneImpl() const
Clone an identical UIToFPInst.
~AllocaInst() override
void setAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope=CrossThread)
Definition: Instructions.h:273
ConstantExpr - a constant value that is initialized with an expression using other constant values...
Definition: Constants.h:852
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
bool isVolatile() const
isVolatile - Return true if this is a cmpxchg from a volatile memory location.
Definition: Instructions.h:544
AtomicOrdering getOrdering() const
Returns the ordering constraint on this RMW.
Definition: Instructions.h:769
void setCleanup(bool V)
setCleanup - Indicate that this landingpad instruction is a cleanup.
BitCastInst * cloneImpl() const
Clone an identical BitCastInst.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
void setValue(ConstantInt *V)
Sets the new value for current case.
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:557
BinOp
This enumeration lists the possible modifications atomicrmw can make.
Definition: Instructions.h:686
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
ExtractValueInst * cloneImpl() const
This instruction compares its operands according to the predicate given to the constructor.
BasicBlock * getSuccessor(unsigned i) const
bool isIntegerCast() const
There are several places where we need to know if a cast instruction only deals with integer source a...
bool isFirstClassType() const
isFirstClassType - Return true if the type is "first class", meaning it is a valid type for a Value...
Definition: Type.h:242
This class represents a no-op cast from one type to another.
StoreInst * cloneImpl() const
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
SIToFPInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
bool isFloatingPointTy() const
isFloatingPointTy - Return true if this is one of the six floating point types
Definition: Type.h:159
Predicate getUnsignedPredicate() const
For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
FPToSIInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
This class represents a cast from floating point to signed integer.
unsigned getNumElements() const
Return the number of elements in the Vector type.
Definition: DerivedTypes.h:432
This class represents a truncation of integer types.
Type * getElementType() const
Definition: DerivedTypes.h:323
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
bool isAtomic() const
isAtomic - Return true if this instruction has an AtomicOrdering of unordered or higher.
static const Value * getNotArgument(const Value *BinOp)
std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type cast(const Y &Val)
Definition: Casting.h:222
bool isInBounds() const
isInBounds - Determine whether the GEP has the inbounds flag.
void addAttribute(unsigned i, Attribute::AttrKind attr)
addAttribute - adds the attribute to the list of attributes.
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
SwitchInst * cloneImpl() const
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
FPTruncInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
void removeAttribute(unsigned i, Attribute attr)
removeAttribute - removes the attribute from the list of attributes.
static Type * getIndexedTypeInternal(Type *Agg, ArrayRef< IndexTy > IdxList)
getIndexedType - Returns the type of the element that would be accessed with a gep instruction with t...
SIToFPInst * cloneImpl() const
Clone an identical SIToFPInst.
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
Definition: Instructions.h:830
LoadInst * cloneImpl() const
bool isX86_MMXTy() const
isX86_MMXTy - Return true if this is X86 MMX.
Definition: Type.h:179
bool isIntOrIntVectorTy() const
isIntOrIntVectorTy - Return true if this is an integer type or a vector of integer types...
Definition: Type.h:201
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:131
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
bool isLosslessCast() const
A lossless cast is one that does not alter the basic value.
InsertElementInst - This instruction inserts a single (scalar) element into a VectorType value...
static BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
LandingPadInst - The landingpad instruction holds all of the information necessary to generate correc...
static CmpInst * Create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2, const Twine &Name="", Instruction *InsertBefore=nullptr)
Construct a compare instruction, given the opcode, the predicate and the two operands.
unsigned getAlignment() const
getAlignment - Return the alignment of the access that is being performed
Definition: Instructions.h:365
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
void copyIRFlags(const Value *V)
Convenience method to copy supported wrapping, exact, and fast-math flags from V to this instruction...
unsigned getCaseIndex() const
Returns number of current case.
void set(Value *Val)
Definition: Value.h:516
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeSet AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:115
SynchronizationScope getSynchScope() const
Returns whether this RMW is atomic between threads or only within a single thread.
Definition: Instructions.h:775
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
Value * hasConstantValue() const
hasConstantValue - If the specified PHI node always merges together the same value, return the value, otherwise return null.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
UnreachableInst(LLVMContext &C, Instruction *InsertBefore=nullptr)
BranchInst - Conditional or Unconditional Branch instruction.
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
UnreachableInst - This function has undefined behavior.
This is an important base class in LLVM.
Definition: Constant.h:41
ResumeInst - Resume the propagation of an exception.
void setFailureOrdering(AtomicOrdering Ordering)
Definition: Instructions.h:576
This file contains the declarations for the subclasses of Constant, which represent the different fla...
void setUsedWithInAlloca(bool V)
Specify whether this alloca is used to represent the arguments to a call.
Definition: Instructions.h:149
IndirectBrInst - Indirect Branch Instruction.
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
unsigned getAlignment() const
getAlignment - Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:130
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:233
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1900
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, AtomicOrdering Ordering, SynchronizationScope SynchScope, Instruction *InsertBefore=nullptr)
~TerminatorInst() override
bool paramHasAttr(unsigned i, Attribute::AttrKind A) const
Determine whether the call or the callee has the given attributes.
static bool isBitCastable(Type *SrcTy, Type *DestTy)
Check whether a bitcast between these types is valid.
op_iterator op_end()
Definition: User.h:185
bool hasAllZeroIndices() const
hasAllZeroIndices - Return true if all of the indices of this GEP are zeros.
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:225
Type * getTypeAtIndex(const Value *V)
getTypeAtIndex - Given an index value into the type, return the type of the element.
Definition: Type.cpp:634
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
bool isFalseWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:844
bool isUsedWithInAlloca() const
Return true if this alloca is used as an inalloca argument to a call.
Definition: Instructions.h:143
This instruction compares its operands according to the predicate given to the constructor.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:697
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1273
iterator begin() const
Definition: ArrayRef.h:122
void addClause(Constant *ClauseVal)
Add a catch or filter clause to the landing pad.
Value * getOperand(unsigned i) const
Definition: User.h:118
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:706
static CastInst * CreatePointerBitCastOrAddrSpaceCast(Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd)
Create a BitCast or an AddrSpaceCast cast instruction.
bool isCommutative() const
isCommutative - Return true if the instruction is commutative:
Definition: Instruction.h:327
static bool isNot(const Value *V)
void addAttribute(unsigned i, Attribute::AttrKind attr)
addAttribute - adds the attribute to the list of attributes.
ConstantVector - Constant Vector Declarations.
Definition: Constants.h:461
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:760
static CastInst * CreatePointerCast(Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd)
Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:129
void setTailCallKind(TailCallKind TCK)
Constant * getAggregateElement(unsigned Elt) const
getAggregateElement - For aggregates (struct/array/vector) return the constant that corresponds to th...
Definition: Constants.cpp:250
void setAlignment(unsigned Align)
This class represents a cast from an integer to a pointer.
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:230
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:714
NUW NUW NUW NUW Exact static Exact BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, const Twine &NameStr="", Instruction *InsertBefor=nullptr)
void setTailCall(bool isTC=true)
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
void andIRFlags(const Value *V)
Logical 'and' of any supported wrapping, exact, and fast-math flags of V and this instruction...
bool isCommutative() const
This is just a convenience that dispatches to the subclasses.
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
FPToUIInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
void anchor() override
void setAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope=CrossThread)
Definition: Instructions.h:395
~UnaryInstruction() override
bool hasAllConstantIndices() const
hasAllConstantIndices - Return true if all of the indices of this GEP are constant integers...
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
static CastInst * CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
bool isFPOrFPVectorTy() const
isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP.
Definition: Type.h:183
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:283
static bool isValidOperands(const Value *Vec, const Value *Idx)
isValidOperands - Return true if an extractelement instruction can be formed with the specified opera...
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:712
void setMetadata(unsigned KindID, MDNode *Node)
setMetadata - Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1083
void swapOperands()
This is just a convenience that dispatches to the subclasses.
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:84
unsigned getNumSuccessors() const
signed greater than
Definition: InstrTypes.h:724
float getFPAccuracy() const
Get the maximum error permitted by this operation in ULPs.
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
void setSuccessor(unsigned idx, BasicBlock *NewSucc)
~CallInst() override
BasicBlock * getSuccessor(unsigned i) const
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag...
hexagon gen pred
static BinaryOperator * CreateNUWNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
TruncInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
bool isConditional() const
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space...
Definition: DataLayout.cpp:694
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:701
BinaryOps getOpcode() const
Definition: InstrTypes.h:323
static BinaryOperator * CreateFNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:936
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt, BitCast, or Trunc for int -> int casts.
BasicBlock * getUnwindDest() const
AtomicOrdering getOrdering() const
Returns the ordering effect of this store.
Definition: Instructions.h:372
static PointerType * getUnqual(Type *ElementType)
PointerType::getUnqual - This constructs a pointer to an object of the specified type in the generic ...
Definition: DerivedTypes.h:460
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
Value * getIncomingValue(unsigned i) const
getIncomingValue - Return incoming value number x
AtomicCmpXchgInst * cloneImpl() const
unsigned getVectorNumElements() const
Definition: Type.cpp:212
unsigned getScalarSizeInBits() const LLVM_READONLY
getScalarSizeInBits - If this is a vector type, return the getPrimitiveSizeInBits value for the eleme...
Definition: Type.cpp:139
AddrSpaceCastInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
ICmpInst * cloneImpl() const
Clone an identical ICmpInst.
unsigned getNumSuccessors() const
ReturnInst * cloneImpl() const
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:711
bool isStaticAlloca() const
isStaticAlloca - Return true if this alloca is in the entry block of the function and is a constant s...
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
MDNode * getMetadata(unsigned KindID) const
getMetadata - Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:167
static bool isCastable(Type *SrcTy, Type *DestTy)
Check whether it is valid to call getCastOpcode for these types.
LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore)
TailCallKind getTailCallKind() const
This class represents a range of values.
Definition: ConstantRange.h:43
InvokeInst * cloneImpl() const
bool isVolatile() const
isVolatile - Return true if this is a load from a volatile memory location.
Definition: Instructions.h:232
signed less than
Definition: InstrTypes.h:726
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:838
This class represents a cast from floating point to unsigned integer.
static CastInst * CreateFPCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create an FPExt, BitCast, or FPTrunc for fp -> fp casts.
static unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, Type *DstIntPtrTy)
Determine how a pair of casts can be eliminated, if they can be at all.
ShuffleVectorInst * cloneImpl() const
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:799
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
Definition: APInt.h:433
VAArgInst * cloneImpl() const
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:582
Function * getCalledFunction() const
getCalledFunction - Return the function called, or null if this is an indirect function invocation...
AtomicOrdering getOrdering() const
Returns the ordering effect of this fence.
Definition: Instructions.h:250
SExtInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
ZExtInst * cloneImpl() const
Clone an identical ZExtInst.
bool isExact() const
Determine whether the exact flag is set.
static cl::opt< AlignMode > Align(cl::desc("Load/store alignment support"), cl::Hidden, cl::init(NoStrictAlign), cl::values(clEnumValN(StrictAlign,"aarch64-strict-align","Disallow all unaligned memory accesses"), clEnumValN(NoStrictAlign,"aarch64-no-strict-align","Allow unaligned memory accesses"), clEnumValEnd))
void setSuccessor(unsigned idx, BasicBlock *NewSucc)
BinOp getOperation() const
Definition: Instructions.h:726
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Definition: InstrTypes.h:765
unsigned Log2_32(uint32_t Value)
Log2_32 - This function returns the floor log base 2 of the specified value, -1 if the value is zero...
Definition: MathExtras.h:468
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const
Accumulate the constant address offset of this GEP if possible.
SynchronizationScope getSynchScope() const
Definition: Instructions.h:480
AttributeSet removeAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Remove the specified attributes at the specified index from this attribute list.
Definition: Attributes.cpp:828
signed less or equal
Definition: InstrTypes.h:727
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
void setVolatile(bool V)
setVolatile - Specify whether this is a volatile store or not.
Definition: Instructions.h:355
static bool isNeg(const Value *V)
Check if the given Value is a NEG, FNeg, or NOT instruction.
Class for arbitrary precision integers.
Definition: APInt.h:73
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, const Twine &Name, Instruction *InsertBefore)
VAArgInst(Value *List, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
void setWeak(bool IsWeak)
Definition: Instructions.h:560
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
ZExtInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
FCmpInst(Instruction *InsertBefore, Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="")
Constructor with insert-before-instruction semantics.
Value * getCondition() const
BitCastInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
const AttributeSet & getAttributes() const
getAttributes - Return the parameter attributes for this call.
static bool isConstantAllOnes(const Value *V)
CompositeType - Common super class of ArrayType, StructType, PointerType and VectorType.
Definition: DerivedTypes.h:148
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
static Instruction * CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy, Type *AllocTy, Value *AllocSize, Value *ArraySize=nullptr, Function *MallocF=nullptr, const Twine &Name="")
CreateMalloc - Generate the IR for a call to malloc:
AllocaInst * cloneImpl() const
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
getIndexedType - Returns the type of the element that would be loaded with a load instruction with th...
static Instruction * createFree(Value *Source, Instruction *InsertBefore, BasicBlock *InsertAtEnd)
InsertElementInst * cloneImpl() const
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1030
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
BasicBlock * getSuccessor(unsigned idx) const
Value * getCondition() const
const AttributeSet & getAttributes() const
getAttributes - Return the parameter attributes for this invoke.
BasicBlock * getDefaultDest() const
AttributeSet addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Attr) const
Add an attribute to the attribute set at the given index.
Definition: Attributes.cpp:753
bool isAggregateType() const
isAggregateType - Return true if the type is an aggregate type.
Definition: Type.h:260
unsigned getNumSuccessors() const
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
AtomicOrdering getOrdering() const
Returns the ordering effect of this fence.
Definition: Instructions.h:469
static CastInst * CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a Trunc or BitCast cast instruction.
unsigned greater or equal
Definition: InstrTypes.h:721
AttributeSet addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given index.
Definition: Attributes.cpp:914
unsigned getAlignment() const
getAlignment - Return the alignment of the access that is being performed
Definition: Instructions.h:243
static bool isFNeg(const Value *V, bool IgnoreZeroSign=false)
void setOperation(BinOp Operation)
Definition: Instructions.h:730
static Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
#define I(x, y, z)
Definition: MD5.cpp:54
void setSuccessor(unsigned idx, BasicBlock *NewSucc)
static Constant * getZeroValueForNegation(Type *Ty)
Floating point negation must be implemented with f(x) = -0.0 - x.
Definition: Constants.cpp:705
This class represents a cast unsigned integer to floating point.
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:705
float convertToFloat() const
Definition: APFloat.cpp:3107
Compile-time customization of User operands.
Definition: User.h:34
static ConstantRange makeConstantRange(Predicate pred, const APInt &C)
Initialize a set of values that all satisfy the predicate with C.
ExtractElementInst - This instruction extracts a single (scalar) element from a VectorType value...
unsigned getNumSuccessors() const
VectorType * getType() const
getType - Overload to return most specific vector type.
bool paramHasAttr(unsigned i, Attribute::AttrKind A) const
Determine whether the call or the callee has the given attributes.
IntToPtrInst * cloneImpl() const
Clone an identical IntToPtrInst.
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
void removeCase(CaseIt i)
removeCase - This method removes the specified case and its successor from the switch instruction...
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:709
unsigned getNumCases() const
getNumCases - return the number of 'cases' in this switch instruction, except the default case ...
void addDestination(BasicBlock *Dest)
addDestination - Add a destination.
ResumeInst * cloneImpl() const
const APFloat & getValueAPF() const
Definition: Constants.h:270
bool isVarArg() const
Definition: DerivedTypes.h:120
SwitchInst - Multiway switch.
static CastInst * CreateSExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a SExt or BitCast cast instruction.
This class represents a cast from signed integer to floating point.
bool isUnsigned() const
Determine if this instruction is using an unsigned comparison.
Definition: InstrTypes.h:832
bool isWeak() const
Return true if this cmpxchg may spuriously fail.
Definition: Instructions.h:556
GetElementPtrInst * cloneImpl() const
void setAttributes(const AttributeSet &Attrs)
setAttributes - Set the parameter attributes for this call.
const ARM::ArchExtKind Kind
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
Definition: APInt.h:436
const BasicBlock & front() const
Definition: Function.h:464
This class represents a truncation of floating point types.
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
~ReturnInst() override
void setSuccessOrdering(AtomicOrdering Ordering)
Set the ordering constraint on this cmpxchg.
Definition: Instructions.h:569
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:700
LLVM Value Representation.
Definition: Value.h:69
void setAlignment(unsigned Align)
FPExtInst(Value *S, Type *Ty, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics.
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
FPToSIInst * cloneImpl() const
Clone an identical FPToSIInst.
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:710
void allocHungoffUses(unsigned N, bool IsPhi=false)
Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User.
Definition: User.cpp:43
const Value * getArraySize() const
getArraySize - Get the number of elements allocated.
Definition: Instructions.h:110
static bool isUnordered(unsigned short predicate)
Determine if the predicate is an unordered operation.
static Value * getAISize(LLVMContext &Context, Value *Amt)
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore)
InvokeInst - Invoke instruction.
void setSynchScope(SynchronizationScope SynchScope)
Specify whether this RMW orders other operations with respect to all concurrently executing threads...
Definition: Instructions.h:763
TruncInst * cloneImpl() const
Clone an identical TruncInst.
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
bool isCleanup() const
isCleanup - Return 'true' if this landingpad instruction is a cleanup.
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:164
unsigned greater than
Definition: InstrTypes.h:720
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering, SynchronizationScope SynchScope, Instruction *InsertBefore=nullptr)
ICmpInst(Instruction *InsertBefore, Predicate pred, Value *LHS, Value *RHS, const Twine &NameStr="")
Constructor with insert-before-instruction semantics.
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
Use & Op()
Definition: User.h:93
static bool isVolatile(Instruction *Inst)
void setNumHungOffUseOperands(unsigned NumOps)
Subclasses with hung off uses need to manage the operand count themselves.
Definition: User.h:169
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2280
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
FenceInst * cloneImpl() const
static BinaryOperator * CreateMul(Value *S1, Value *S2, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
Type * getAllocatedType() const
getAllocatedType - Return the type that is being allocated by the instruction.
Definition: Instructions.h:122
This class represents an extension of floating point types.
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:702
void setVolatile(bool V)
setVolatile - Specify whether this is a volatile load or not.
Definition: Instructions.h:236
SynchronizationScope getSynchScope() const
Returns whether this cmpxchg is atomic between threads or only within a single thread.
Definition: Instructions.h:603
FPTruncInst * cloneImpl() const
Clone an identical FPTruncInst.
InsertValueInst * cloneImpl() const
Root of the metadata hierarchy.
Definition: Metadata.h:45
unsigned getNumSuccessors() const
void removeDestination(unsigned i)
removeDestination - This method removes the specified successor from the indirectbr instruction...
const BasicBlock * getParent() const
Definition: Instruction.h:72
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
Definition: Constants.h:169
SmallVector< int, 16 > getShuffleMask() const
FenceInst(LLVMContext &C, AtomicOrdering Ordering, SynchronizationScope SynchScope=CrossThread, Instruction *InsertBefore=nullptr)
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:699
signed greater or equal
Definition: InstrTypes.h:725
AddrSpaceCastInst * cloneImpl() const
Clone an identical AddrSpaceCastInst.
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:265
PHINode * cloneImpl() const
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:137
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
SelectInst * cloneImpl() const
void * addr
InsertValueInst - This instruction inserts a struct field of array element value into an aggregate va...
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:64
bool isVolatile() const
isVolatile - Return true if this is a RMW on a volatile memory location.
Definition: Instructions.h:738
static const char * areInvalidOperands(Value *Cond, Value *True, Value *False)
areInvalidOperands - Return a string if the specified operands are invalid for a select operation...