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