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