LLVM API Documentation

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