revert unnecessary changes

[electriclilies]

Oops, this is not ready, still figuring out arcanist

llvm/lib/IR/Instructions.cpp

if (VectorType *VT = dyn_cast<VectorType>(Op0->getType())) {
     // Vector select.
     if (VT->getElementType() != Type::getInt1Ty(Op0->getContext()))
       return "vector select condition element type must be i1";
     VectorType *ET = dyn_cast<VectorType>(Op1->getType());
     if (!ET)
       return "selected values for vector select must be vectors";
     if (ET->getElementCount() != VT->getElementCount())
       return "vector select requires selected vectors to have "
                    "the same vector length as select condition";
   } else if (Op0->getType() != Type::getInt1Ty(Op0->getContext())) {
     return "select condition must be i1 or <n x i1>";
   }
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 //                               PHINode Class

 
 /// growOperands - grow operands - This grows the operand list in response
 /// to a push_back style of operation.  This grows the number of ops by 1.5
 /// times.
 ///
 void PHINode::growOperands() {
   unsigned e = getNumOperands();
   unsigned NumOps = e + e / 2;
-  if (NumOps < 2)
-    NumOps = 2; // 2 op PHI nodes are VERY common.
+  if (NumOps < 2) NumOps = 2;      // 2 op PHI nodes are VERY common.
 
   ReservedSpace = NumOps;
   growHungoffUses(ReservedSpace, /* IsPhi */ true);
 }
 
 /// hasConstantValue - If the specified PHI node always merges together the same
 /// value, return the value, otherwise return null.
 Value *PHINode::hasConstantValue() const {
   // Exploit the fact that phi nodes always have at least one entry.
   Value *ConstantValue = getIncomingValue(0);
   for (unsigned i = 1, e = getNumIncomingValues(); i != e; ++i)
     if (getIncomingValue(i) != ConstantValue && getIncomingValue(i) != this) {
       if (ConstantValue != this)
         return nullptr; // Incoming values not all the same.
-                        // The case where the first value is this PHI.
       ConstantValue = getIncomingValue(i);
     }
   if (ConstantValue == this)
     return UndefValue::get(getType());
   return ConstantValue;
 }
 
 /// hasConstantOrUndefValue - Whether the specified PHI node always merges
void LandingPadInst::init(unsigned NumReservedValues, const Twine &NameStr) {
   setName(NameStr);
   setCleanup(false);
 }
 
 /// growOperands - grow operands - This grows the operand list in response to a
 /// push_back style of operation. This grows the number of ops by 2 times.
 void LandingPadInst::growOperands(unsigned Size) {
   unsigned e = getNumOperands();
-  if (ReservedSpace >= e + Size)
-    return;
+  if (ReservedSpace >= e + Size) return;
   ReservedSpace = (std::max(e, 1U) + Size / 2) * 2;
   growHungoffUses(ReservedSpace);
 }
 
 void LandingPadInst::addClause(Constant *Val) {
   unsigned OpNo = getNumOperands();
   growOperands(1);
   assert(OpNo < ReservedSpace && "Growing didn't work!");
for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) {
     auto ChildOB = CI->getOperandBundleAt(i);
     if (ChildOB.getTagName() != OpB.getTag())
       OpDefs.emplace_back(ChildOB);
   }
   OpDefs.emplace_back(OpB);
   return CallBase::Create(CI, OpDefs, InsertPt);
 }
 
+
 Function *CallBase::getCaller() { return getParent()->getParent(); }
 
 unsigned CallBase::getNumSubclassExtraOperandsDynamic() const {
   assert(getOpcode() == Instruction::CallBr && "Unexpected opcode!");
   return cast<CallBrInst>(this)->getNumIndirectDests() + 1;
 }
 
 bool CallBase::isIndirectCall() const {
void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
   this->FTy = FTy;
   assert(getNumOperands() == Args.size() + CountBundleInputs(Bundles) + 1 &&
          "NumOperands not set up?");
 
 #ifndef NDEBUG
   assert((Args.size() == FTy->getNumParams() ||
           (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
          "Calling a function with bad signature!");
-  for (unsigned i = 0; i != Args.size(); ++i) {
+
+  for (unsigned i = 0; i != Args.size(); ++i)
     assert((i >= FTy->getNumParams() ||
             FTy->getParamType(i) == Args[i]->getType()) &&
            "Calling a function with a bad signature!");
-  }
 #endif
 
   // Set operands in order of their index to match use-list-order
   // prediction.
   llvm::copy(Args, op_begin());
   setCalledOperand(Func);
 
   auto It = populateBundleOperandInfos(Bundles, Args.size());
for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
       // Don't scale the magic number.
       if (Count == NOMORE_ICP_MAGICNUM) {
         Vals.push_back(ProfileData->getOperand(i + 1));
         continue;
       }
       // Using APInt::div may be expensive, but most cases should fit 64 bits.
       APInt Val(128, Count);
       Val *= APS;
-      Vals.push_back(MDB.createConstant(ConstantInt::get(
-          Type::getInt64Ty(getContext()), Val.udiv(APT).getLimitedValue())));
+      Vals.push_back(MDB.createConstant(
+          ConstantInt::get(Type::getInt64Ty(getContext()),
+                           Val.udiv(APT).getLimitedValue())));
     }
   setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Vals));
 }
 
 /// IsConstantOne - Return true only if val is constant int 1
 static bool IsConstantOne(Value *val) {
   assert(val && "IsConstantOne does not work with nullptr val");
   const ConstantInt *CVal = dyn_cast<ConstantInt>(val);
static Instruction *createMalloc(Instruction *InsertBefore,
   // malloc(type) becomes:
   //       bitcast (i8* malloc(typeSize)) to type*
   // malloc(type, arraySize) becomes:
   //       bitcast (i8* malloc(typeSize*arraySize)) to type*
   if (!ArraySize)
     ArraySize = ConstantInt::get(IntPtrTy, 1);
   else if (ArraySize->getType() != IntPtrTy) {
     if (InsertBefore)
-      ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false, "",
-                                              InsertBefore);
+      ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false,
+                                              "", InsertBefore);
     else
-      ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false, "",
-                                              InsertAtEnd);
+      ArraySize = CastInst::CreateIntegerCast(ArraySize, IntPtrTy, false,
+                                              "", InsertAtEnd);
   }
 
   if (!IsConstantOne(ArraySize)) {
     if (IsConstantOne(AllocSize)) {
-      AllocSize = ArraySize; // Operand * 1 = Operand
+      AllocSize = ArraySize;         // Operand * 1 = Operand
     } else if (Constant *CO = dyn_cast<Constant>(ArraySize)) {
-      Constant *Scale =
-          ConstantExpr::getIntegerCast(CO, IntPtrTy, false /*ZExt*/);
+      Constant *Scale = ConstantExpr::getIntegerCast(CO, IntPtrTy,
+                                                     false /*ZExt*/);
       // Malloc arg is constant product of type size and array size
       AllocSize = ConstantExpr::getMul(Scale, cast<Constant>(AllocSize));
     } else {
       // Multiply type size by the array size...
       if (InsertBefore)
         AllocSize = BinaryOperator::CreateMul(ArraySize, AllocSize,
                                               "mallocsize", InsertBefore);
       else

 }
 
 /// CreateMalloc - Generate the IR for a call to malloc:
 /// 1. Compute the malloc call's argument as the specified type's size,
 ///    possibly multiplied by the array size if the array size is not
 ///    constant 1.
 /// 2. Call malloc with that argument.
 /// 3. Bitcast the result of the malloc call to the specified type.
-Instruction *CallInst::CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
-                                    Type *AllocTy, Value *AllocSize,
-                                    Value *ArraySize, Function *MallocF,
+Instruction *CallInst::CreateMalloc(Instruction *InsertBefore,
+                                    Type *IntPtrTy, Type *AllocTy,
+                                    Value *AllocSize, Value *ArraySize,
+                                    Function *MallocF,
                                     const Twine &Name) {
   return createMalloc(InsertBefore, nullptr, IntPtrTy, AllocTy, AllocSize,
                       ArraySize, None, MallocF, Name);
 }
-Instruction *CallInst::CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
-                                    Type *AllocTy, Value *AllocSize,
-                                    Value *ArraySize,
+Instruction *CallInst::CreateMalloc(Instruction *InsertBefore,
+                                    Type *IntPtrTy, Type *AllocTy,
+                                    Value *AllocSize, Value *ArraySize,
                                     ArrayRef<OperandBundleDef> OpB,
-                                    Function *MallocF, const Twine &Name) {
+                                    Function *MallocF,
+                                    const Twine &Name) {
   return createMalloc(InsertBefore, nullptr, IntPtrTy, AllocTy, AllocSize,
                       ArraySize, OpB, MallocF, Name);
 }
 
 /// CreateMalloc - Generate the IR for a call to malloc:
 /// 1. Compute the malloc call's argument as the specified type's size,
 ///    possibly multiplied by the array size if the array size is not
 ///    constant 1.
 /// 2. Call malloc with that argument.
 /// 3. Bitcast the result of the malloc call to the specified type.
 /// Note: This function does not add the bitcast to the basic block, that is the
 /// responsibility of the caller.
-Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
-                                    Type *AllocTy, Value *AllocSize,
-                                    Value *ArraySize, Function *MallocF,
-                                    const Twine &Name) {
+Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd,
+                                    Type *IntPtrTy, Type *AllocTy,
+                                    Value *AllocSize, Value *ArraySize,
+                                    Function *MallocF, const Twine &Name) {
   return createMalloc(nullptr, InsertAtEnd, IntPtrTy, AllocTy, AllocSize,
                       ArraySize, None, MallocF, Name);
 }
-Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
-                                    Type *AllocTy, Value *AllocSize,
-                                    Value *ArraySize,
+Instruction *CallInst::CreateMalloc(BasicBlock *InsertAtEnd,
+                                    Type *IntPtrTy, Type *AllocTy,
+                                    Value *AllocSize, Value *ArraySize,
                                     ArrayRef<OperandBundleDef> OpB,
                                     Function *MallocF, const Twine &Name) {
   return createMalloc(nullptr, InsertAtEnd, IntPtrTy, AllocTy, AllocSize,
                       ArraySize, OpB, MallocF, Name);
 }
 
 static Instruction *createFree(Value *Source,
                                ArrayRef<OperandBundleDef> Bundles,

 
 static Align computeAllocaDefaultAlign(Type *Ty, Instruction *I) {
   assert(I && "Insertion position cannot be null when alignment not provided!");
   return computeAllocaDefaultAlign(Ty, I->getParent());
 }
 
 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
                        Instruction *InsertBefore)
-    : AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertBefore) {}
 
 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
                        BasicBlock *InsertAtEnd)
-    : AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertAtEnd) {}
 
 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
                        const Twine &Name, Instruction *InsertBefore)
     : AllocaInst(Ty, AddrSpace, ArraySize,
                  computeAllocaDefaultAlign(Ty, InsertBefore), Name,
                  InsertBefore) {}
 
 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
     : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca,
                        getAISize(Ty->getContext(), ArraySize), InsertAtEnd),
       AllocatedType(Ty) {
   setAlignment(Align);
   assert(!Ty->isVoidTy() && "Cannot allocate void!");
   setName(Name);
 }
 
+
 bool AllocaInst::isArrayAllocation() const {
   if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0)))
     return !CI->isOne();
   return true;
 }
 
 /// isStaticAlloca - Return true if this alloca is in the entry block of the
 /// function and is a constant size.  If so, the code generator will fold it
 /// into the prolog/epilog code, so it is basically free.
 bool AllocaInst::isStaticAlloca() const {
   // Must be constant size.
-  if (!isa<ConstantInt>(getArraySize()))
-    return false;
+  if (!isa<ConstantInt>(getArraySize())) return false;
 
   // Must be in the entry block.
   const BasicBlock *Parent = getParent();
   return Parent == &Parent->getParent()->front() && !isUsedWithInAlloca();
 }
 
 //===----------------------------------------------------------------------===//
 //                           LoadInst Implementation
StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align,
   Op<0>() = val;
   Op<1>() = addr;
   setVolatile(isVolatile);
   setAlignment(Align);
   setAtomic(Order, SSID);
   AssertOK();
 }
 
+
 //===----------------------------------------------------------------------===//
 //                       AtomicCmpXchgInst Implementation
 //===----------------------------------------------------------------------===//
 
 void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal,
                              Align Alignment, AtomicOrdering SuccessOrdering,
                              AtomicOrdering FailureOrdering,
                              SyncScope::ID SSID) {
assert(Ordering != AtomicOrdering::Unordered &&
          "atomicrmw instructions cannot be unordered.");
   Op<0>() = Ptr;
   Op<1>() = Val;
   setOperation(Operation);
   setOrdering(Ordering);
   setSyncScopeID(SSID);
   setAlignment(Alignment);
 
-  assert(getOperand(0) && getOperand(1) && "All operands must be non-null!");
+  assert(getOperand(0) && getOperand(1) &&
+         "All operands must be non-null!");
   assert(getOperand(0)->getType()->isPointerTy() &&
          "Ptr must have pointer type!");
   assert(cast<PointerType>(getOperand(0)->getType())
              ->isOpaqueOrPointeeTypeMatches(getOperand(1)->getType()) &&
          "Ptr must be a pointer to Val type!");
   assert(Ordering != AtomicOrdering::NotAtomic &&
          "AtomicRMW instructions must be atomic!");
 }
StringRef AtomicRMWInst::getOperationName(BinOp Op) {
   llvm_unreachable("invalid atomicrmw operation");
 }
 
 //===----------------------------------------------------------------------===//
 //                       FenceInst Implementation
 //===----------------------------------------------------------------------===//
 
 FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering,
-                     SyncScope::ID SSID, Instruction *InsertBefore)
-    : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) {
+                     SyncScope::ID SSID,
+                     Instruction *InsertBefore)
   setOrdering(Ordering);
   setSyncScopeID(SSID);
 }
 
 FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering,
-                     SyncScope::ID SSID, BasicBlock *InsertAtEnd)
-    : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) {
+                     SyncScope::ID SSID,
+                     BasicBlock *InsertAtEnd)
   setOrdering(Ordering);
   setSyncScopeID(SSID);
 }
 
 //===----------------------------------------------------------------------===//
 //                       GetElementPtrInst Implementation
 //===----------------------------------------------------------------------===//
 

 }
 
 /// hasAllZeroIndices - Return true if all of the indices of this GEP are
 /// zeros.  If so, the result pointer and the first operand have the same
 /// value, just potentially different types.
 bool GetElementPtrInst::hasAllZeroIndices() const {
   for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
     if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(i))) {
-      if (!CI->isZero())
-        return false;
+      if (!CI->isZero()) return false;
     } else {
       return false;
     }
   }
   return true;
 }
 
 /// hasAllConstantIndices - Return true if all of the indices of this GEP are

 bool GetElementPtrInst::accumulateConstantOffset(const DataLayout &DL,
                                                  APInt &Offset) const {
   // Delegate to the generic GEPOperator implementation.
   return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset);
 }
 
 bool GetElementPtrInst::collectOffset(
     const DataLayout &DL, unsigned BitWidth,
-    MapVector<Value *, APInt> &VariableOffsets, APInt &ConstantOffset) const {
+    MapVector<Value *, APInt> &VariableOffsets,
+    APInt &ConstantOffset) const {
   // Delegate to the generic GEPOperator implementation.
   return cast<GEPOperator>(this)->collectOffset(DL, BitWidth, VariableOffsets,
                                                 ConstantOffset);
 }
 
 //===----------------------------------------------------------------------===//
 //                           ExtractElementInst Implementation
 //===----------------------------------------------------------------------===//
 
 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
                                        const Twine &Name,
                                        Instruction *InsertBef)
-    : Instruction(
-          cast<VectorType>(Val->getType())->getElementType(), ExtractElement,
-          OperandTraits<ExtractElementInst>::op_begin(this), 2, InsertBef) {
+  : Instruction(cast<VectorType>(Val->getType())->getElementType(),
+                ExtractElement,
+                OperandTraits<ExtractElementInst>::op_begin(this),
+                2, InsertBef) {
   assert(isValidOperands(Val, Index) &&
          "Invalid extractelement instruction operands!");
   Op<0>() = Val;
   Op<1>() = Index;
   setName(Name);
 }
 
 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
-                                       const Twine &Name, BasicBlock *InsertAE)
-    : Instruction(
-          cast<VectorType>(Val->getType())->getElementType(), ExtractElement,
-          OperandTraits<ExtractElementInst>::op_begin(this), 2, InsertAE) {
+                                       const Twine &Name,
+                                       BasicBlock *InsertAE)
+  : Instruction(cast<VectorType>(Val->getType())->getElementType(),
+                ExtractElement,
+                OperandTraits<ExtractElementInst>::op_begin(this),
+                2, InsertAE) {
   assert(isValidOperands(Val, Index) &&
          "Invalid extractelement instruction operands!");
 
   Op<0>() = Val;
   Op<1>() = Index;
   setName(Name);
 }
 
 bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
   if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy())
     return false;
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 //                           InsertElementInst Implementation
 //===----------------------------------------------------------------------===//
 
 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
-                                     const Twine &Name, Instruction *InsertBef)
-    : Instruction(Vec->getType(), InsertElement,
-                  OperandTraits<InsertElementInst>::op_begin(this), 3,
-                  InsertBef) {
+                                     const Twine &Name,
+                                     Instruction *InsertBef)
+                OperandTraits<InsertElementInst>::op_begin(this),
+                3, InsertBef) {
   assert(isValidOperands(Vec, Elt, Index) &&
          "Invalid insertelement instruction operands!");
   Op<0>() = Vec;
   Op<1>() = Elt;
   Op<2>() = Index;
   setName(Name);
 }
 
 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
-                                     const Twine &Name, BasicBlock *InsertAE)
-    : Instruction(Vec->getType(), InsertElement,
-                  OperandTraits<InsertElementInst>::op_begin(this), 3,
-                  InsertAE) {
+                                     const Twine &Name,
+                                     BasicBlock *InsertAE)
+                OperandTraits<InsertElementInst>::op_begin(this),
+                3, InsertAE) {
   assert(isValidOperands(Vec, Elt, Index) &&
          "Invalid insertelement instruction operands!");
 
   Op<0>() = Vec;
   Op<1>() = Elt;
   Op<2>() = Index;
   setName(Name);
 }
 
 bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
                                         const Value *Index) {
   if (!Vec->getType()->isVectorTy())
-    return false; // First operand of insertelement must be vector type.
+    return false;   // First operand of insertelement must be vector type.
 
   if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType())
-    return false; // Second operand of insertelement must be vector element
-                  // type.
+    return false;// Second operand of insertelement must be vector element type.
 
   if (!Index->getType()->isIntegerTy())
-    return false; // Third operand of insertelement must be i32.
+    return false;  // Third operand of insertelement must be i32.
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 //                      ShuffleVectorInst Implementation
 //===----------------------------------------------------------------------===//
 
 static Value *createPlaceholderForShuffleVector(Value *V) {
bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
   // Check to see if Mask is valid.
   if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask))
     return true;
 
   if (const auto *MV = dyn_cast<ConstantVector>(Mask)) {
     unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements();
     for (Value *Op : MV->operands()) {
       if (auto *CI = dyn_cast<ConstantInt>(Op)) {
-        if (CI->uge(V1Size * 2))
+        if (CI->uge(V1Size*2))
           return false;
       } else if (!isa<UndefValue>(Op)) {
         return false;
       }
     }
     return true;
   }
 
   if (const auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) {
     unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements();
     for (unsigned i = 0, e = cast<FixedVectorType>(MaskTy)->getNumElements();
          i != e; ++i)
-      if (CDS->getElementAsInteger(i) >= V1Size * 2)
+      if (CDS->getElementAsInteger(i) >= V1Size*2)
         return false;
     return true;
   }
 
   return false;
 }
 
 void ShuffleVectorInst::getShuffleMask(const Constant *Mask,
void ShuffleVectorInst::getShuffleMask(const Constant *Mask,
 
   if (auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) {
     for (unsigned i = 0; i != NumElts; ++i)
       Result.push_back(CDS->getElementAsInteger(i));
     return;
   }
   for (unsigned i = 0; i != NumElts; ++i) {
     Constant *C = Mask->getAggregateElement(i);
-    Result.push_back(isa<UndefValue>(C) ? -1
-                                        : cast<ConstantInt>(C)->getZExtValue());
+    Result.push_back(isa<UndefValue>(C) ? -1 :
+                     cast<ConstantInt>(C)->getZExtValue());
   }
 }
 
 void ShuffleVectorInst::setShuffleMask(ArrayRef<int> Mask) {
   ShuffleMask.assign(Mask.begin(), Mask.end());
   ShuffleMaskForBitcode = convertShuffleMaskForBitcode(Mask, getType());
 }
 
if (I == -1)
       continue;
     assert(I >= 0 && I < (NumOpElts * 2) &&
            "Out-of-bounds shuffle mask element");
     UsesLHS |= (I < NumOpElts);
     UsesRHS |= (I >= NumOpElts);
     if (UsesLHS && UsesRHS)
       return false;
   }
-  // Allow for degenerate case: completely undef mask means neither source is
-  // used.
+  // Allow for degenerate case: completely undef mask means neither source is used.
   return UsesLHS || UsesRHS;
 }
 
 bool ShuffleVectorInst::isSingleSourceMask(ArrayRef<int> Mask) {
   // We don't have vector operand size information, so assume operands are the
   // same size as the mask.
   return isSingleSourceMaskImpl(Mask, Mask.size());
 }
void InsertValueInst::init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
 
   // There's no fundamental reason why we require at least one index
   // (other than weirdness with &*IdxBegin being invalid; see
   // getelementptr's init routine for example). But there's no
   // present need to support it.
   assert(!Idxs.empty() && "InsertValueInst must have at least one index");
 
   assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs) ==
-             Val->getType() &&
-         "Inserted value must match indexed type!");
+         Val->getType() && "Inserted value must match indexed type!");
   Op<0>() = Agg;
   Op<1>() = Val;
 
   Indices.append(Idxs.begin(), Idxs.end());
   setName(Name);
 }
 
 InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
-    : Instruction(IVI.getType(), InsertValue,
-                  OperandTraits<InsertValueInst>::op_begin(this), 2),
-      Indices(IVI.Indices) {
   Op<0>() = IVI.getOperand(0);
   Op<1>() = IVI.getOperand(1);
   SubclassOptionalData = IVI.SubclassOptionalData;
 }
 
 //===----------------------------------------------------------------------===//
 //                             ExtractValueInst Class
 //===----------------------------------------------------------------------===//
 
 void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) {
   assert(getNumOperands() == 1 && "NumOperands not initialized?");
 
   // There's no fundamental reason why we require at least one index.
   // But there's no present need to support it.
   assert(!Idxs.empty() && "ExtractValueInst must have at least one index");
 
   Indices.append(Idxs.begin(), Idxs.end());
   setName(Name);
 }
 
 ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI)
-    : UnaryInstruction(EVI.getType(), ExtractValue, EVI.getOperand(0)),
-      Indices(EVI.Indices) {
   SubclassOptionalData = EVI.SubclassOptionalData;
 }
 
 // getIndexedType - Returns the type of the element that would be extracted
 // with an extractvalue instruction with the specified parameters.
 //
 // A null type is returned if the indices are invalid for the specified
 // pointer type.
 //
-Type *ExtractValueInst::getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs) {
+Type *ExtractValueInst::getIndexedType(Type *Agg,
+                                       ArrayRef<unsigned> Idxs) {
   for (unsigned Index : Idxs) {
     // We can't use CompositeType::indexValid(Index) here.
     // indexValid() always returns true for arrays because getelementptr allows
     // out-of-bounds indices. Since we don't allow those for extractvalue and
     // insertvalue we need to check array indexing manually.
     // Since the only other types we can index into are struct types it's just
     // as easy to check those manually as well.
     if (ArrayType *AT = dyn_cast<ArrayType>(Agg)) {
       if (Index >= AT->getNumElements())
         return nullptr;
       Agg = AT->getElementType();
     } else if (StructType *ST = dyn_cast<StructType>(Agg)) {
       if (Index >= ST->getNumElements())
         return nullptr;
       Agg = ST->getElementType(Index);
     } else {
       // Not a valid type to index into.
       return nullptr;
     }
   }
-  return const_cast<Type *>(Agg);
+  return const_cast<Type*>(Agg);
 }
 
 //===----------------------------------------------------------------------===//
 //                             UnaryOperator Class
 //===----------------------------------------------------------------------===//
 
-UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
-                             const Twine &Name, Instruction *InsertBefore)
-    : UnaryInstruction(Ty, iType, S, InsertBefore) {
+UnaryOperator::UnaryOperator(UnaryOps iType, Value *S,
+                             Type *Ty, const Twine &Name,
+                             Instruction *InsertBefore)
   Op<0>() = S;
   setName(Name);
   AssertOK();
 }
 
-UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
-                             const Twine &Name, BasicBlock *InsertAtEnd)
-    : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
+UnaryOperator::UnaryOperator(UnaryOps iType, Value *S,
+                             Type *Ty, const Twine &Name,
+                             BasicBlock *InsertAtEnd)
   Op<0>() = S;
   setName(Name);
   AssertOK();
 }
 
-UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S, const Twine &Name,
+UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
+                                     const Twine &Name,
                                      Instruction *InsertBefore) {
   return new UnaryOperator(Op, S, S->getType(), Name, InsertBefore);
 }
 
-UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S, const Twine &Name,
+UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
+                                     const Twine &Name,
                                      BasicBlock *InsertAtEnd) {
   UnaryOperator *Res = Create(Op, S, Name);
   InsertAtEnd->getInstList().push_back(Res);
   return Res;
 }
 
 void UnaryOperator::AssertOK() {
   Value *LHS = getOperand(0);
   (void)LHS; // Silence warnings.
 #ifndef NDEBUG
   switch (getOpcode()) {
   case FNeg:
     assert(getType() == LHS->getType() &&
            "Unary operation should return same type as operand!");
     assert(getType()->isFPOrFPVectorTy() &&
            "Tried to create a floating-point operation on a "
            "non-floating-point type!");
     break;
-  default:
-    llvm_unreachable("Invalid opcode provided");
+  default: llvm_unreachable("Invalid opcode provided");
   }
 #endif
 }
 
 //===----------------------------------------------------------------------===//
 //                             BinaryOperator Class
 //===----------------------------------------------------------------------===//
 
-BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
-                               const Twine &Name, Instruction *InsertBefore)
-    : Instruction(Ty, iType, OperandTraits<BinaryOperator>::op_begin(this),
-                  OperandTraits<BinaryOperator>::operands(this), InsertBefore) {
+BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
+                               Type *Ty, const Twine &Name,
+                               Instruction *InsertBefore)
+  : Instruction(Ty, iType,
+                OperandTraits<BinaryOperator>::op_begin(this),
+                OperandTraits<BinaryOperator>::operands(this),
+                InsertBefore) {
   Op<0>() = S1;
   Op<1>() = S2;
   setName(Name);
   AssertOK();
 }
 
-BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
-                               const Twine &Name, BasicBlock *InsertAtEnd)
-    : Instruction(Ty, iType, OperandTraits<BinaryOperator>::op_begin(this),
-                  OperandTraits<BinaryOperator>::operands(this), InsertAtEnd) {
+BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
+                               Type *Ty, const Twine &Name,
+                               BasicBlock *InsertAtEnd)
+  : Instruction(Ty, iType,
+                OperandTraits<BinaryOperator>::op_begin(this),
+                OperandTraits<BinaryOperator>::operands(this),
+                InsertAtEnd) {
   Op<0>() = S1;
   Op<1>() = S2;
   setName(Name);
   AssertOK();
 }
 
 void BinaryOperator::AssertOK() {
   Value *LHS = getOperand(0), *RHS = getOperand(1);
-  (void)LHS;
-  (void)RHS; // Silence warnings.
+  (void)LHS; (void)RHS; // Silence warnings.
   assert(LHS->getType() == RHS->getType() &&
          "Binary operator operand types must match!");
 #ifndef NDEBUG
   switch (getOpcode()) {
-  case Add:
-  case Sub:
+  case Add: case Sub:
   case Mul:
     assert(getType() == LHS->getType() &&
            "Arithmetic operation should return same type as operands!");
     assert(getType()->isIntOrIntVectorTy() &&
            "Tried to create an integer operation on a non-integer type!");
     break;
-  case FAdd:
-  case FSub:
+  case FAdd: case FSub:
   case FMul:
     assert(getType() == LHS->getType() &&
            "Arithmetic operation should return same type as operands!");
     assert(getType()->isFPOrFPVectorTy() &&
            "Tried to create a floating-point operation on a "
            "non-floating-point type!");
     break;
   case UDiv:
#ifndef NDEBUG
   case Shl:
   case LShr:
   case AShr:
     assert(getType() == LHS->getType() &&
            "Shift operation should return same type as operands!");
     assert(getType()->isIntOrIntVectorTy() &&
            "Tried to create a shift operation on a non-integral type!");
     break;
-  case And:
-  case Or:
+  case And: case Or:
   case Xor:
     assert(getType() == LHS->getType() &&
            "Logical operation should return same type as operands!");
     assert(getType()->isIntOrIntVectorTy() &&
            "Tried to create a logical operation on a non-integral type!");
     break;
-  default:
-    llvm_unreachable("Invalid opcode provided");
+  default: llvm_unreachable("Invalid opcode provided");
   }
 #endif
 }
 
 BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2,
                                        const Twine &Name,
                                        Instruction *InsertBefore) {
   assert(S1->getType() == S2->getType() &&
          "Cannot create binary operator with two operands of differing type!");
   return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore);
 }
 
 BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2,
                                        const Twine &Name,
                                        BasicBlock *InsertAtEnd) {
   BinaryOperator *Res = Create(Op, S1, S2, Name);
   InsertAtEnd->getInstList().push_back(Res);
   return Res;
 }
 
 BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name,
                                           Instruction *InsertBefore) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
-  return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name,
-                            InsertBefore);
+  return new BinaryOperator(Instruction::Sub,
+                            zero, Op,
+                            Op->getType(), Name, InsertBefore);
 }
 
 BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name,
                                           BasicBlock *InsertAtEnd) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
-  return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name,
-                            InsertAtEnd);
+  return new BinaryOperator(Instruction::Sub,
+                            zero, Op,
+                            Op->getType(), Name, InsertAtEnd);
 }
 
 BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name,
                                              Instruction *InsertBefore) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return BinaryOperator::CreateNSWSub(zero, Op, Name, InsertBefore);
 }
 
BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name,
                                              BasicBlock *InsertAtEnd) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd);
 }
 
 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,
                                           Instruction *InsertBefore) {
   Constant *C = Constant::getAllOnesValue(Op->getType());
-  return new BinaryOperator(Instruction::Xor, Op, C, Op->getType(), Name,
-                            InsertBefore);
+  return new BinaryOperator(Instruction::Xor, Op, C,
+                            Op->getType(), Name, InsertBefore);
 }
 
 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,
                                           BasicBlock *InsertAtEnd) {
   Constant *AllOnes = Constant::getAllOnesValue(Op->getType());
-  return new BinaryOperator(Instruction::Xor, Op, AllOnes, Op->getType(), Name,
-                            InsertAtEnd);
+  return new BinaryOperator(Instruction::Xor, Op, AllOnes,
+                            Op->getType(), Name, InsertAtEnd);
 }
 
 // Exchange the two operands to this instruction. This instruction is safe to
 // use on any binary instruction and does not modify the semantics of the
 // instruction. If the instruction is order-dependent (SetLT f.e.), the opcode
 // is changed.
 bool BinaryOperator::swapOperands() {
   if (!isCommutative())

 
 //===----------------------------------------------------------------------===//
 //                                CastInst Class
 //===----------------------------------------------------------------------===//
 
 // Just determine if this cast only deals with integral->integral conversion.
 bool CastInst::isIntegerCast() const {
   switch (getOpcode()) {
-  default:
-    return false;
+    default: return false;
     case Instruction::ZExt:
     case Instruction::SExt:
     case Instruction::Trunc:
       return true;
     case Instruction::BitCast:
-    return getOperand(0)->getType()->isIntegerTy() && getType()->isIntegerTy();
+      return getOperand(0)->getType()->isIntegerTy() &&
+        getType()->isIntegerTy();
   }
 }
 
 bool CastInst::isLosslessCast() const {
   // Only BitCast can be lossless, exit fast if we're not BitCast
   if (getOpcode() != Instruction::BitCast)
     return false;
 
   // Identity cast is always lossless
   Type *SrcTy = getOperand(0)->getType();
   Type *DstTy = getType();
   if (SrcTy == DstTy)
     return true;
 
   // Pointer to pointer is always lossless.
   if (SrcTy->isPointerTy())
     return DstTy->isPointerTy();
-  return false; // Other types have no identity values
+  return false;  // Other types have no identity values
 }
 
 /// This function determines if the CastInst does not require any bits to be
 /// changed in order to effect the cast. Essentially, it identifies cases where
 /// no code gen is necessary for the cast, hence the name no-op cast.  For
 /// example, the following are all no-op casts:
 /// # bitcast i32* %x to i8*
 /// # bitcast <2 x i32> %x to <4 x i16>
 /// # ptrtoint i32* %x to i32     ; on 32-bit plaforms only
 /// Determine if the described cast is a no-op.
-bool CastInst::isNoopCast(Instruction::CastOps Opcode, Type *SrcTy,
-                          Type *DestTy, const DataLayout &DL) {
+bool CastInst::isNoopCast(Instruction::CastOps Opcode,
+                          Type *SrcTy,
+                          Type *DestTy,
+                          const DataLayout &DL) {
   assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition");
   switch (Opcode) {
-  default:
-    llvm_unreachable("Invalid CastOp");
+    default: llvm_unreachable("Invalid CastOp");
     case Instruction::Trunc:
     case Instruction::ZExt:
     case Instruction::SExt:
     case Instruction::FPTrunc:
     case Instruction::FPExt:
     case Instruction::UIToFP:
     case Instruction::SIToFP:
     case Instruction::FPToUI:
     case Instruction::FPToSI:
     case Instruction::AddrSpaceCast:
       // TODO: Target informations may give a more accurate answer here.
       return false;
     case Instruction::BitCast:
-    return true; // BitCast never modifies bits.
+      return true;  // BitCast never modifies bits.
     case Instruction::PtrToInt:
       return DL.getIntPtrType(SrcTy)->getScalarSizeInBits() ==
              DestTy->getScalarSizeInBits();
     case Instruction::IntToPtr:
       return DL.getIntPtrType(DestTy)->getScalarSizeInBits() ==
              SrcTy->getScalarSizeInBits();
   }
 }
 
 bool CastInst::isNoopCast(const DataLayout &DL) const {
   return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), DL);
 }
 
 /// This function determines if a pair of casts can be eliminated and what
 /// opcode should be used in the elimination. This assumes that there are two
 /// instructions like this:
 /// *  %F = firstOpcode SrcTy %x to MidTy
 /// *  %S = secondOpcode MidTy %F to DstTy
 /// The function returns a resultOpcode so these two casts can be replaced with:
 /// *  %Replacement = resultOpcode %SrcTy %x to DstTy
 /// If no such cast is permitted, the function returns 0.
-unsigned CastInst::isEliminableCastPair(Instruction::CastOps firstOp,
-                                        Instruction::CastOps secondOp,
-                                        Type *SrcTy, Type *MidTy, Type *DstTy,
-                                        Type *SrcIntPtrTy, Type *MidIntPtrTy,
-                                        Type *DstIntPtrTy) {
+unsigned CastInst::isEliminableCastPair(
+  Instruction::CastOps firstOp, Instruction::CastOps secondOp,
+  Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
   // Define the 144 possibilities for these two cast instructions. The values
   // in this matrix determine what to do in a given situation and select the
   // case in the switch below.  The rows correspond to firstOp, the columns
   // correspond to secondOp.  In looking at the table below, keep in mind
   // the following cast properties:
   //
   //          Size Compare       Source               Destination
   // Operator  Src ? Size   Type       Sign         Type       Sign
unsigned CastInst::isEliminableCastPair(
   // NOTE: some transforms are safe, but we consider them to be non-profitable.
   // For example, we could merge "fptoui double to i32" + "zext i32 to i64",
   // into "fptoui double to i64", but this loses information about the range
   // of the produced value (we no longer know the top-part is all zeros).
   // Further this conversion is often much more expensive for typical hardware,
   // and causes issues when building libgcc.  We disallow fptosi+sext for the
   // same reason.
   const unsigned numCastOps =
-      Instruction::CastOpsEnd - Instruction::CastOpsBegin;
   static const uint8_t CastResults[numCastOps][numCastOps] = {
-      // T        F  F  U  S  F  F  P  I  B  A  -+
-      // R  Z  S  P  P  I  I  T  P  2  N  T  S   |
-      // U  E  E  2  2  2  2  R  E  I  T  C  C   +- secondOp
-      // N  X  X  U  S  F  F  N  X  N  2  V  V   |
-      // C  T  T  I  I  P  P  C  T  T  P  T  T  -+
-      {1, 0, 0, 99, 99, 0, 0, 99, 99, 99, 0, 3, 0},  // Trunc         -+
-      {8, 1, 9, 99, 99, 2, 17, 99, 99, 99, 2, 3, 0}, // ZExt           |
-      {8, 0, 1, 99, 99, 0, 2, 99, 99, 99, 0, 3, 0},  // SExt           |
-      {0, 0, 0, 99, 99, 0, 0, 99, 99, 99, 0, 3, 0},  // FPToUI         |
-      {0, 0, 0, 99, 99, 0, 0, 99, 99, 99, 0, 3, 0},  // FPToSI         |
-      {99, 99, 99, 0, 0, 99, 99, 0, 0, 99, 99, 4,
-       0}, // UIToFP         +- firstOp
-      {99, 99, 99, 0, 0, 99, 99, 0, 0, 99, 99, 4, 0},      // SIToFP         |
-      {99, 99, 99, 0, 0, 99, 99, 0, 0, 99, 99, 4, 0},      // FPTrunc        |
-      {99, 99, 99, 2, 2, 99, 99, 8, 2, 99, 99, 4, 0},      // FPExt          |
-      {1, 0, 0, 99, 99, 0, 0, 99, 99, 99, 7, 3, 0},        // PtrToInt       |
-      {99, 99, 99, 99, 99, 99, 99, 99, 99, 11, 99, 15, 0}, // IntToPtr       |
-      {5, 5, 5, 6, 6, 5, 5, 6, 6, 16, 5, 1, 14},           // BitCast        |
-      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 12},           // AddrSpaceCast -+
+    {  1, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // Trunc         -+
+    {  8, 1, 9,99,99, 2,17,99,99,99, 2, 3, 0}, // ZExt           |
+    {  8, 0, 1,99,99, 0, 2,99,99,99, 0, 3, 0}, // SExt           |
+    {  0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToUI         |
+    {  0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToSI         |
+    { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // UIToFP         +- firstOp
+    { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // SIToFP         |
+    { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // FPTrunc        |
+    { 99,99,99, 2, 2,99,99, 8, 2,99,99, 4, 0}, // FPExt          |
+    {  1, 0, 0,99,99, 0, 0,99,99,99, 7, 3, 0}, // PtrToInt       |
+    { 99,99,99,99,99,99,99,99,99,11,99,15, 0}, // IntToPtr       |
+    {  5, 5, 5, 6, 6, 5, 5, 6, 6,16, 5, 1,14}, // BitCast        |
+    {  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,13,12}, // AddrSpaceCast -+
   };
 
   // TODO: This logic could be encoded into the table above and handled in the
   // switch below.
   // If either of the casts are a bitcast from scalar to vector, disallow the
   // merging. However, any pair of bitcasts are allowed.
-  bool IsFirstBitcast = (firstOp == Instruction::BitCast);
+  bool IsFirstBitcast  = (firstOp == Instruction::BitCast);
   bool IsSecondBitcast = (secondOp == Instruction::BitCast);
   bool AreBothBitcasts = IsFirstBitcast && IsSecondBitcast;
 
   // Check if any of the casts convert scalars <-> vectors.
-  if ((IsFirstBitcast && isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) ||
+  if ((IsFirstBitcast  && isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) ||
       (IsSecondBitcast && isa<VectorType>(MidTy) != isa<VectorType>(DstTy)))
     if (!AreBothBitcasts)
       return 0;
 
-  int ElimCase = CastResults[firstOp - Instruction::CastOpsBegin]
-                            [secondOp - Instruction::CastOpsBegin];
+  int ElimCase = CastResults[firstOp-Instruction::CastOpsBegin]
+                            [secondOp-Instruction::CastOpsBegin];
   switch (ElimCase) {
     case 0:
       // Categorically disallowed.
       return 0;
     case 1:
       // Allowed, use first cast's opcode.
       return firstOp;
     case 2:
       // Allowed, use second cast's opcode.
       return secondOp;
     case 3:
       // No-op cast in second op implies firstOp as long as the DestTy
       // is integer and we are not converting between a vector and a
       // non-vector type.
       if (!SrcTy->isVectorTy() && DstTy->isIntegerTy())
         return firstOp;
       return 0;
     case 4:
       // No-op cast in second op implies firstOp as long as the DestTy
       // is floating point.
       if (DstTy->isFloatingPointTy())
         return firstOp;
       return 0;
     case 5:
       // No-op cast in first op implies secondOp as long as the SrcTy
       // is an integer.
       if (SrcTy->isIntegerTy())
         return secondOp;
       return 0;
     case 6:
       // No-op cast in first op implies secondOp as long as the SrcTy
       // is a floating point.
       if (SrcTy->isFloatingPointTy())
         return secondOp;
       return 0;
     case 7: {
       // Disable inttoptr/ptrtoint optimization if enabled.
       if (DisableI2pP2iOpt)
         return 0;
 
       // Cannot simplify if address spaces are different!
       if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace())
         return 0;
 
       unsigned MidSize = MidTy->getScalarSizeInBits();
       // We can still fold this without knowing the actual sizes as long we
       // know that the intermediate pointer is the largest possible
       // pointer size.
       // FIXME: Is this always true?
       if (MidSize == 64)
         return Instruction::BitCast;
 
       // ptrtoint, inttoptr -> bitcast (ptr -> ptr) if int size is >= ptr size.
       if (!SrcIntPtrTy || DstIntPtrTy != SrcIntPtrTy)
         return 0;
       unsigned PtrSize = SrcIntPtrTy->getScalarSizeInBits();
       if (MidSize >= PtrSize)
         return Instruction::BitCast;
       return 0;
     }
     case 8: {
       // ext, trunc -> bitcast,    if the SrcTy and DstTy are the same
       // ext, trunc -> ext,        if sizeof(SrcTy) < sizeof(DstTy)
       // ext, trunc -> trunc,      if sizeof(SrcTy) > sizeof(DstTy)
       unsigned SrcSize = SrcTy->getScalarSizeInBits();
       unsigned DstSize = DstTy->getScalarSizeInBits();
       if (SrcTy == DstTy)
         return Instruction::BitCast;
       if (SrcSize < DstSize)
         return firstOp;
       if (SrcSize > DstSize)
         return secondOp;
       return 0;
     }
     case 9:
       // zext, sext -> zext, because sext can't sign extend after zext
       return Instruction::ZExt;
     case 11: {
       // inttoptr, ptrtoint -> bitcast if SrcSize<=PtrSize and SrcSize==DstSize
       if (!MidIntPtrTy)
         return 0;
       unsigned PtrSize = MidIntPtrTy->getScalarSizeInBits();
       unsigned SrcSize = SrcTy->getScalarSizeInBits();
       unsigned DstSize = DstTy->getScalarSizeInBits();
       if (SrcSize <= PtrSize && SrcSize == DstSize)
         return Instruction::BitCast;
       return 0;
     }
     case 12:
       // addrspacecast, addrspacecast -> bitcast,       if SrcAS == DstAS
       // addrspacecast, addrspacecast -> addrspacecast, if SrcAS != DstAS
       if (SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace())
         return Instruction::AddrSpaceCast;
       return Instruction::BitCast;
     case 13:
       // FIXME: this state can be merged with (1), but the following assert
       // is useful to check the correcteness of the sequence due to semantic
       // change of bitcast.
-    assert(SrcTy->isPtrOrPtrVectorTy() && MidTy->isPtrOrPtrVectorTy() &&
-           DstTy->isPtrOrPtrVectorTy() &&
-           SrcTy->getPointerAddressSpace() != MidTy->getPointerAddressSpace() &&
-           MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() &&
-           "Illegal addrspacecast, bitcast sequence!");
+      assert(
+        SrcTy->isPtrOrPtrVectorTy() &&
+        MidTy->isPtrOrPtrVectorTy() &&
       // Allowed, use first cast's opcode
       return firstOp;
     case 14: {
       // bitcast, addrspacecast -> addrspacecast if the element type of
       // bitcast's source is the same as that of addrspacecast's destination.
       PointerType *SrcPtrTy = cast<PointerType>(SrcTy->getScalarType());
       PointerType *DstPtrTy = cast<PointerType>(DstTy->getScalarType());
       if (SrcPtrTy->hasSameElementTypeAs(DstPtrTy))
         return Instruction::AddrSpaceCast;
       return 0;
     }
     case 15:
       // FIXME: this state can be merged with (1), but the following assert
       // is useful to check the correcteness of the sequence due to semantic
       // change of bitcast.
-    assert(SrcTy->isIntOrIntVectorTy() && MidTy->isPtrOrPtrVectorTy() &&
-           DstTy->isPtrOrPtrVectorTy() &&
-           MidTy->getPointerAddressSpace() == DstTy->getPointerAddressSpace() &&
-           "Illegal inttoptr, bitcast sequence!");
+      assert(
+        SrcTy->isIntOrIntVectorTy() &&
+        MidTy->isPtrOrPtrVectorTy() &&
       // Allowed, use first cast's opcode
       return firstOp;
     case 16:
       // FIXME: this state can be merged with (2), but the following assert
       // is useful to check the correcteness of the sequence due to semantic
       // change of bitcast.
-    assert(SrcTy->isPtrOrPtrVectorTy() && MidTy->isPtrOrPtrVectorTy() &&
-           DstTy->isIntOrIntVectorTy() &&
-           SrcTy->getPointerAddressSpace() == MidTy->getPointerAddressSpace() &&
-           "Illegal bitcast, ptrtoint sequence!");
+      assert(
+        SrcTy->isPtrOrPtrVectorTy() &&
+        MidTy->isPtrOrPtrVectorTy() &&
       // Allowed, use second cast's opcode
       return secondOp;
     case 17:
       // (sitofp (zext x)) -> (uitofp x)
       return Instruction::UIToFP;
     case 99:
       // Cast combination can't happen (error in input). This is for all cases
       // where the MidTy is not the same for the two cast instructions.
       llvm_unreachable("Invalid Cast Combination");
     default:
       llvm_unreachable("Error in CastResults table!!!");
   }
 }
 
 CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
-                           const Twine &Name, Instruction *InsertBefore) {
   assert(castIsValid(op, S, Ty) && "Invalid cast!");
   // Construct and return the appropriate CastInst subclass
   switch (op) {
-  case Trunc:
-    return new TruncInst(S, Ty, Name, InsertBefore);
-  case ZExt:
-    return new ZExtInst(S, Ty, Name, InsertBefore);
-  case SExt:
-    return new SExtInst(S, Ty, Name, InsertBefore);
-  case FPTrunc:
-    return new FPTruncInst(S, Ty, Name, InsertBefore);
-  case FPExt:
-    return new FPExtInst(S, Ty, Name, InsertBefore);
-  case UIToFP:
-    return new UIToFPInst(S, Ty, Name, InsertBefore);
-  case SIToFP:
-    return new SIToFPInst(S, Ty, Name, InsertBefore);
-  case FPToUI:
-    return new FPToUIInst(S, Ty, Name, InsertBefore);
-  case FPToSI:
-    return new FPToSIInst(S, Ty, Name, InsertBefore);
-  case PtrToInt:
-    return new PtrToIntInst(S, Ty, Name, InsertBefore);
-  case IntToPtr:
-    return new IntToPtrInst(S, Ty, Name, InsertBefore);
-  case BitCast:
-    return new BitCastInst(S, Ty, Name, InsertBefore);
-  case AddrSpaceCast:
-    return new AddrSpaceCastInst(S, Ty, Name, InsertBefore);
-  default:
-    llvm_unreachable("Invalid opcode provided");
+  case Trunc:         return new TruncInst         (S, Ty, Name, InsertBefore);
+  case ZExt:          return new ZExtInst          (S, Ty, Name, InsertBefore);
+  case SExt:          return new SExtInst          (S, Ty, Name, InsertBefore);
+  case FPTrunc:       return new FPTruncInst       (S, Ty, Name, InsertBefore);
+  case FPExt:         return new FPExtInst         (S, Ty, Name, InsertBefore);
+  case UIToFP:        return new UIToFPInst        (S, Ty, Name, InsertBefore);
+  case SIToFP:        return new SIToFPInst        (S, Ty, Name, InsertBefore);
+  case FPToUI:        return new FPToUIInst        (S, Ty, Name, InsertBefore);
+  case FPToSI:        return new FPToSIInst        (S, Ty, Name, InsertBefore);
+  case PtrToInt:      return new PtrToIntInst      (S, Ty, Name, InsertBefore);
+  case IntToPtr:      return new IntToPtrInst      (S, Ty, Name, InsertBefore);
+  case BitCast:       return new BitCastInst       (S, Ty, Name, InsertBefore);
+  case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertBefore);
+  default: llvm_unreachable("Invalid opcode provided");
   }
 }
 
 CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
-                           const Twine &Name, BasicBlock *InsertAtEnd) {
   assert(castIsValid(op, S, Ty) && "Invalid cast!");
   // Construct and return the appropriate CastInst subclass
   switch (op) {
-  case Trunc:
-    return new TruncInst(S, Ty, Name, InsertAtEnd);
-  case ZExt:
-    return new ZExtInst(S, Ty, Name, InsertAtEnd);
-  case SExt:
-    return new SExtInst(S, Ty, Name, InsertAtEnd);
-  case FPTrunc:
-    return new FPTruncInst(S, Ty, Name, InsertAtEnd);
-  case FPExt:
-    return new FPExtInst(S, Ty, Name, InsertAtEnd);
-  case UIToFP:
-    return new UIToFPInst(S, Ty, Name, InsertAtEnd);
-  case SIToFP:
-    return new SIToFPInst(S, Ty, Name, InsertAtEnd);
-  case FPToUI:
-    return new FPToUIInst(S, Ty, Name, InsertAtEnd);
-  case FPToSI:
-    return new FPToSIInst(S, Ty, Name, InsertAtEnd);
-  case PtrToInt:
-    return new PtrToIntInst(S, Ty, Name, InsertAtEnd);
-  case IntToPtr:
-    return new IntToPtrInst(S, Ty, Name, InsertAtEnd);
-  case BitCast:
-    return new BitCastInst(S, Ty, Name, InsertAtEnd);
-  case AddrSpaceCast:
-    return new AddrSpaceCastInst(S, Ty, Name, InsertAtEnd);
-  default:
-    llvm_unreachable("Invalid opcode provided");
+  case Trunc:         return new TruncInst         (S, Ty, Name, InsertAtEnd);
+  case ZExt:          return new ZExtInst          (S, Ty, Name, InsertAtEnd);
+  case SExt:          return new SExtInst          (S, Ty, Name, InsertAtEnd);
+  case FPTrunc:       return new FPTruncInst       (S, Ty, Name, InsertAtEnd);
+  case FPExt:         return new FPExtInst         (S, Ty, Name, InsertAtEnd);
+  case UIToFP:        return new UIToFPInst        (S, Ty, Name, InsertAtEnd);
+  case SIToFP:        return new SIToFPInst        (S, Ty, Name, InsertAtEnd);
+  case FPToUI:        return new FPToUIInst        (S, Ty, Name, InsertAtEnd);
+  case FPToSI:        return new FPToSIInst        (S, Ty, Name, InsertAtEnd);
+  case PtrToInt:      return new PtrToIntInst      (S, Ty, Name, InsertAtEnd);
+  case IntToPtr:      return new IntToPtrInst      (S, Ty, Name, InsertAtEnd);
+  case BitCast:       return new BitCastInst       (S, Ty, Name, InsertAtEnd);
+  case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertAtEnd);
+  default: llvm_unreachable("Invalid opcode provided");
   }
 }
 
-CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
+                                        const Twine &Name,
                                         Instruction *InsertBefore) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
   return Create(Instruction::ZExt, S, Ty, Name, InsertBefore);
 }
 
-CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
+                                        const Twine &Name,
                                         BasicBlock *InsertAtEnd) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
   return Create(Instruction::ZExt, S, Ty, Name, InsertAtEnd);
 }
 
-CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty,
+                                        const Twine &Name,
                                         Instruction *InsertBefore) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
   return Create(Instruction::SExt, S, Ty, Name, InsertBefore);
 }
 
-CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty,
+                                        const Twine &Name,
                                         BasicBlock *InsertAtEnd) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
   return Create(Instruction::SExt, S, Ty, Name, InsertAtEnd);
 }
 
-CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty,
+                                         const Twine &Name,
                                          Instruction *InsertBefore) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
   return Create(Instruction::Trunc, S, Ty, Name, InsertBefore);
 }
 
-CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty,
+                                         const Twine &Name,
                                          BasicBlock *InsertAtEnd) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
   return Create(Instruction::Trunc, S, Ty, Name, InsertAtEnd);
 }
 
-CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
+                                      const Twine &Name,
                                       BasicBlock *InsertAtEnd) {
   assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
   assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
          "Invalid cast");
   assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
   assert((!Ty->isVectorTy() ||
           cast<VectorType>(Ty)->getElementCount() ==
               cast<VectorType>(S->getType())->getElementCount()) &&
          "Invalid cast");
 
   if (Ty->isIntOrIntVectorTy())
     return Create(Instruction::PtrToInt, S, Ty, Name, InsertAtEnd);
 
   return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertAtEnd);
 }
 
 /// Create a BitCast or a PtrToInt cast instruction
-CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
+                                      const Twine &Name,
                                       Instruction *InsertBefore) {
   assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
   assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
          "Invalid cast");
   assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
   assert((!Ty->isVectorTy() ||
           cast<VectorType>(Ty)->getElementCount() ==
               cast<VectorType>(S->getType())->getElementCount()) &&
          "Invalid cast");
 
   if (Ty->isIntOrIntVectorTy())
     return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
 
   return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertBefore);
 }
 
 CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast(
-    Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd) {
+  Value *S, Type *Ty,
+  const Twine &Name,
+  BasicBlock *InsertAtEnd) {
   assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
   assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
 
   if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
     return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertAtEnd);
 
   return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
 }
 
 CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast(
-    Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore) {
+  Value *S, Type *Ty,
+  const Twine &Name,
+  Instruction *InsertBefore) {
   assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
   assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
 
   if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
     return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertBefore);
 
   return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
 }
 
 CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty,
                                            const Twine &Name,
                                            Instruction *InsertBefore) {
   if (S->getType()->isPointerTy() && Ty->isIntegerTy())
     return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
   if (S->getType()->isIntegerTy() && Ty->isPointerTy())
     return Create(Instruction::IntToPtr, S, Ty, Name, InsertBefore);
 
   return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
 }
 
-CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, bool isSigned,
-                                      const Twine &Name,
+CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
+                                      bool isSigned, const Twine &Name,
                                       Instruction *InsertBefore) {
   assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() &&
          "Invalid integer cast");
   unsigned SrcBits = C->getType()->getScalarSizeInBits();
   unsigned DstBits = Ty->getScalarSizeInBits();
   Instruction::CastOps opcode =
-      (SrcBits == DstBits
-           ? Instruction::BitCast
-           : (SrcBits > DstBits
-                  ? Instruction::Trunc
-                  : (isSigned ? Instruction::SExt : Instruction::ZExt)));
+    (SrcBits == DstBits ? Instruction::BitCast :
+     (SrcBits > DstBits ? Instruction::Trunc :
+      (isSigned ? Instruction::SExt : Instruction::ZExt)));
   return Create(opcode, C, Ty, Name, InsertBefore);
 }
 
-CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, bool isSigned,
-                                      const Twine &Name,
+CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
+                                      bool isSigned, const Twine &Name,
                                       BasicBlock *InsertAtEnd) {
   assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() &&
          "Invalid cast");
   unsigned SrcBits = C->getType()->getScalarSizeInBits();
   unsigned DstBits = Ty->getScalarSizeInBits();
   Instruction::CastOps opcode =
-      (SrcBits == DstBits
-           ? Instruction::BitCast
-           : (SrcBits > DstBits
-                  ? Instruction::Trunc
-                  : (isSigned ? Instruction::SExt : Instruction::ZExt)));
+    (SrcBits == DstBits ? Instruction::BitCast :
+     (SrcBits > DstBits ? Instruction::Trunc :
+      (isSigned ? Instruction::SExt : Instruction::ZExt)));
   return Create(opcode, C, Ty, Name, InsertAtEnd);
 }
 
-CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateFPCast(Value *C, Type *Ty,
+                                 const Twine &Name,
                                  Instruction *InsertBefore) {
   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
          "Invalid cast");
   unsigned SrcBits = C->getType()->getScalarSizeInBits();
   unsigned DstBits = Ty->getScalarSizeInBits();
   Instruction::CastOps opcode =
-      (SrcBits == DstBits
-           ? Instruction::BitCast
-           : (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
+    (SrcBits == DstBits ? Instruction::BitCast :
+     (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
   return Create(opcode, C, Ty, Name, InsertBefore);
 }
 
-CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, const Twine &Name,
+CastInst *CastInst::CreateFPCast(Value *C, Type *Ty,
+                                 const Twine &Name,
                                  BasicBlock *InsertAtEnd) {
   assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
          "Invalid cast");
   unsigned SrcBits = C->getType()->getScalarSizeInBits();
   unsigned DstBits = Ty->getScalarSizeInBits();
   Instruction::CastOps opcode =
-      (SrcBits == DstBits
-           ? Instruction::BitCast
-           : (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
+    (SrcBits == DstBits ? Instruction::BitCast :
+     (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
   return Create(opcode, C, Ty, Name, InsertAtEnd);
 }
 
 bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
   if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType())
     return false;
 
   if (SrcTy == DestTy)

 }
 
 // Provide a way to get a "cast" where the cast opcode is inferred from the
 // types and size of the operand. This, basically, is a parallel of the
 // logic in the castIsValid function below.  This axiom should hold:
 //   castIsValid( getCastOpcode(Val, Ty), Val, Ty)
 // should not assert in castIsValid. In other words, this produces a "correct"
 // casting opcode for the arguments passed to it.
-Instruction::CastOps CastInst::getCastOpcode(const Value *Src, bool SrcIsSigned,
-                                             Type *DestTy, bool DestIsSigned) {
+Instruction::CastOps
+CastInst::getCastOpcode(
+  const Value *Src, bool SrcIsSigned, Type *DestTy, bool DestIsSigned) {
   Type *SrcTy = Src->getType();
 
   assert(SrcTy->isFirstClassType() && DestTy->isFirstClassType() &&
          "Only first class types are castable!");
 
   if (SrcTy == DestTy)
     return BitCast;
 
   // FIXME: Check address space sizes here
   if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy))
     if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy))
       if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) {
         // An element by element cast.  Find the appropriate opcode based on the
         // element types.
         SrcTy = SrcVecTy->getElementType();
         DestTy = DestVecTy->getElementType();
       }
 
   // Get the bit sizes, we'll need these
   unsigned SrcBits = SrcTy->getPrimitiveSizeInBits();   // 0 for ptr
   unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
 
   // Run through the possibilities ...
-  if (DestTy->isIntegerTy()) {  // Casting to integral
-    if (SrcTy->isIntegerTy()) { // Casting from integral
+  if (DestTy->isIntegerTy()) {                      // Casting to integral
+    if (SrcTy->isIntegerTy()) {                     // Casting from integral
       if (DestBits < SrcBits)
-        return Trunc;                // int -> smaller int
-      else if (DestBits > SrcBits) { // its an extension
+        return Trunc;                               // int -> smaller int
+      else if (DestBits > SrcBits) {                // its an extension
         if (SrcIsSigned)
-          return SExt; // signed -> SEXT
+          return SExt;                              // signed -> SEXT
         else
-          return ZExt; // unsigned -> ZEXT
+          return ZExt;                              // unsigned -> ZEXT
       } else {
-        return BitCast; // Same size, No-op cast
+        return BitCast;                             // Same size, No-op cast
       }
-    } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt
+    } else if (SrcTy->isFloatingPointTy()) {        // Casting from floating pt
       if (DestIsSigned)
-        return FPToSI; // FP -> sint
+        return FPToSI;                              // FP -> sint
       else
-        return FPToUI; // FP -> uint
+        return FPToUI;                              // FP -> uint
     } else if (SrcTy->isVectorTy()) {
       assert(DestBits == SrcBits &&
              "Casting vector to integer of different width");
-      return BitCast; // Same size, no-op cast
+      return BitCast;                             // Same size, no-op cast
     } else {
       assert(SrcTy->isPointerTy() &&
              "Casting from a value that is not first-class type");
-      return PtrToInt; // ptr -> int
+      return PtrToInt;                              // ptr -> int
     }
-  } else if (DestTy->isFloatingPointTy()) { // Casting to floating pt
-    if (SrcTy->isIntegerTy()) {             // Casting from integral
+  } else if (DestTy->isFloatingPointTy()) {         // Casting to floating pt
+    if (SrcTy->isIntegerTy()) {                     // Casting from integral
       if (SrcIsSigned)
-        return SIToFP; // sint -> FP
+        return SIToFP;                              // sint -> FP
       else
-        return UIToFP;                       // uint -> FP
-    } else if (SrcTy->isFloatingPointTy()) { // Casting from floating pt
+        return UIToFP;                              // uint -> FP
+    } else if (SrcTy->isFloatingPointTy()) {        // Casting from floating pt
       if (DestBits < SrcBits) {
-        return FPTrunc; // FP -> smaller FP
+        return FPTrunc;                             // FP -> smaller FP
       } else if (DestBits > SrcBits) {
-        return FPExt; // FP -> larger FP
-      } else {
-        return BitCast; // same size, no-op cast
+        return FPExt;                               // FP -> larger FP
+      } else  {
+        return BitCast;                             // same size, no-op cast
       }
     } else if (SrcTy->isVectorTy()) {
       assert(DestBits == SrcBits &&
              "Casting vector to floating point of different width");
-      return BitCast; // same size, no-op cast
+      return BitCast;                             // same size, no-op cast
     }
     llvm_unreachable("Casting pointer or non-first class to float");
   } else if (DestTy->isVectorTy()) {
     assert(DestBits == SrcBits &&
            "Illegal cast to vector (wrong type or size)");
     return BitCast;
   } else if (DestTy->isPointerTy()) {
     if (SrcTy->isPointerTy()) {
       if (DestTy->getPointerAddressSpace() != SrcTy->getPointerAddressSpace())
         return AddrSpaceCast;
-      return BitCast; // ptr -> ptr
+      return BitCast;                               // ptr -> ptr
     } else if (SrcTy->isIntegerTy()) {
-      return IntToPtr; // int -> ptr
+      return IntToPtr;                              // int -> ptr
     }
     llvm_unreachable("Casting pointer to other than pointer or int");
   } else if (DestTy->isX86_MMXTy()) {
     if (SrcTy->isVectorTy()) {
       assert(DestBits == SrcBits && "Casting vector of wrong width to X86_MMX");
-      return BitCast; // 64-bit vector to MMX
+      return BitCast;                               // 64-bit vector to MMX
     }
     llvm_unreachable("Illegal cast to X86_MMX");
   }
   llvm_unreachable("Casting to type that is not first-class");
 }
 
 //===----------------------------------------------------------------------===//
 //                    CastInst SubClass Constructors
 //===----------------------------------------------------------------------===//
 
 /// Check that the construction parameters for a CastInst are correct. This
 /// could be broken out into the separate constructors but it is useful to have
 /// it in one place and to eliminate the redundant code for getting the sizes
 /// of the types involved.
-bool CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
+bool
+CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
   if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() ||
       SrcTy->isAggregateType() || DstTy->isAggregateType())
     return false;
 
   // Get the size of the types in bits, and whether we are dealing
   // with vector types, we'll need this later.
   bool SrcIsVec = isa<VectorType>(SrcTy);
   bool DstIsVec = isa<VectorType>(DstTy);
   unsigned SrcScalarBitSize = SrcTy->getScalarSizeInBits();
   unsigned DstScalarBitSize = DstTy->getScalarSizeInBits();
 
   // If these are vector types, get the lengths of the vectors (using zero for
   // scalar types means that checking that vector lengths match also checks that
   // scalars are not being converted to vectors or vectors to scalars).
   ElementCount SrcEC = SrcIsVec ? cast<VectorType>(SrcTy)->getElementCount()
                                 : ElementCount::getFixed(0);
   ElementCount DstEC = DstIsVec ? cast<VectorType>(DstTy)->getElementCount()
                                 : ElementCount::getFixed(0);
 
   // Switch on the opcode provided
   switch (op) {
-  default:
-    return false; // This is an input error
+  default: return false; // This is an input error
   case Instruction::Trunc:
     return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
            SrcEC == DstEC && SrcScalarBitSize > DstScalarBitSize;
   case Instruction::ZExt:
     return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
            SrcEC == DstEC && SrcScalarBitSize < DstScalarBitSize;
   case Instruction::SExt:
     return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
case Instruction::AddrSpaceCast: {
     if (SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace())
       return false;
 
     return SrcEC == DstEC;
   }
   }
 }
 
-TruncInst::TruncInst(Value *S, Type *Ty, const Twine &Name,
-                     Instruction *InsertBefore)
-    : CastInst(Ty, Trunc, S, Name, InsertBefore) {
+TruncInst::TruncInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, Trunc, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
 }
 
-TruncInst::TruncInst(Value *S, Type *Ty, const Twine &Name,
-                     BasicBlock *InsertAtEnd)
-    : CastInst(Ty, Trunc, S, Name, InsertAtEnd) {
+TruncInst::TruncInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, Trunc, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
 }
 
-ZExtInst::ZExtInst(Value *S, Type *Ty, const Twine &Name,
-                   Instruction *InsertBefore)
-    : CastInst(Ty, ZExt, S, Name, InsertBefore) {
+ZExtInst::ZExtInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+)  : CastInst(Ty, ZExt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
 }
 
-ZExtInst::ZExtInst(Value *S, Type *Ty, const Twine &Name,
-                   BasicBlock *InsertAtEnd)
-    : CastInst(Ty, ZExt, S, Name, InsertAtEnd) {
+ZExtInst::ZExtInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+)  : CastInst(Ty, ZExt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
 }
-SExtInst::SExtInst(Value *S, Type *Ty, const Twine &Name,
-                   Instruction *InsertBefore)
-    : CastInst(Ty, SExt, S, Name, InsertBefore) {
+SExtInst::SExtInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, SExt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
 }
 
-SExtInst::SExtInst(Value *S, Type *Ty, const Twine &Name,
-                   BasicBlock *InsertAtEnd)
-    : CastInst(Ty, SExt, S, Name, InsertAtEnd) {
+SExtInst::SExtInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+)  : CastInst(Ty, SExt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
 }
 
-FPTruncInst::FPTruncInst(Value *S, Type *Ty, const Twine &Name,
-                         Instruction *InsertBefore)
-    : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
+FPTruncInst::FPTruncInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
 }
 
-FPTruncInst::FPTruncInst(Value *S, Type *Ty, const Twine &Name,
-                         BasicBlock *InsertAtEnd)
-    : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) {
+FPTruncInst::FPTruncInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
 }
 
-FPExtInst::FPExtInst(Value *S, Type *Ty, const Twine &Name,
-                     Instruction *InsertBefore)
-    : CastInst(Ty, FPExt, S, Name, InsertBefore) {
+FPExtInst::FPExtInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, FPExt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
 }
 
-FPExtInst::FPExtInst(Value *S, Type *Ty, const Twine &Name,
-                     BasicBlock *InsertAtEnd)
-    : CastInst(Ty, FPExt, S, Name, InsertAtEnd) {
+FPExtInst::FPExtInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, FPExt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
 }
 
-UIToFPInst::UIToFPInst(Value *S, Type *Ty, const Twine &Name,
-                       Instruction *InsertBefore)
-    : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
+UIToFPInst::UIToFPInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
 }
 
-UIToFPInst::UIToFPInst(Value *S, Type *Ty, const Twine &Name,
-                       BasicBlock *InsertAtEnd)
-    : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) {
+UIToFPInst::UIToFPInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
 }
 
-SIToFPInst::SIToFPInst(Value *S, Type *Ty, const Twine &Name,
-                       Instruction *InsertBefore)
-    : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
+SIToFPInst::SIToFPInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
 }
 
-SIToFPInst::SIToFPInst(Value *S, Type *Ty, const Twine &Name,
-                       BasicBlock *InsertAtEnd)
-    : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) {
+SIToFPInst::SIToFPInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
 }
 
-FPToUIInst::FPToUIInst(Value *S, Type *Ty, const Twine &Name,
-                       Instruction *InsertBefore)
-    : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
+FPToUIInst::FPToUIInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
 }
 
-FPToUIInst::FPToUIInst(Value *S, Type *Ty, const Twine &Name,
-                       BasicBlock *InsertAtEnd)
-    : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) {
+FPToUIInst::FPToUIInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
 }
 
-FPToSIInst::FPToSIInst(Value *S, Type *Ty, const Twine &Name,
-                       Instruction *InsertBefore)
-    : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
+FPToSIInst::FPToSIInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
 }
 
-FPToSIInst::FPToSIInst(Value *S, Type *Ty, const Twine &Name,
-                       BasicBlock *InsertAtEnd)
-    : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) {
+FPToSIInst::FPToSIInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
 }
 
-PtrToIntInst::PtrToIntInst(Value *S, Type *Ty, const Twine &Name,
-                           Instruction *InsertBefore)
-    : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
+PtrToIntInst::PtrToIntInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
 }
 
-PtrToIntInst::PtrToIntInst(Value *S, Type *Ty, const Twine &Name,
-                           BasicBlock *InsertAtEnd)
-    : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) {
+PtrToIntInst::PtrToIntInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
 }
 
-IntToPtrInst::IntToPtrInst(Value *S, Type *Ty, const Twine &Name,
-                           Instruction *InsertBefore)
-    : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
+IntToPtrInst::IntToPtrInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
 }
 
-IntToPtrInst::IntToPtrInst(Value *S, Type *Ty, const Twine &Name,
-                           BasicBlock *InsertAtEnd)
-    : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) {
+IntToPtrInst::IntToPtrInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
 }
 
-BitCastInst::BitCastInst(Value *S, Type *Ty, const Twine &Name,
-                         Instruction *InsertBefore)
-    : CastInst(Ty, BitCast, S, Name, InsertBefore) {
+BitCastInst::BitCastInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, BitCast, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
 }
 
-BitCastInst::BitCastInst(Value *S, Type *Ty, const Twine &Name,
-                         BasicBlock *InsertAtEnd)
-    : CastInst(Ty, BitCast, S, Name, InsertAtEnd) {
+BitCastInst::BitCastInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
 }
 
-AddrSpaceCastInst::AddrSpaceCastInst(Value *S, Type *Ty, const Twine &Name,
-                                     Instruction *InsertBefore)
-    : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
+AddrSpaceCastInst::AddrSpaceCastInst(
+  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
+) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
 }
 
-AddrSpaceCastInst::AddrSpaceCastInst(Value *S, Type *Ty, const Twine &Name,
-                                     BasicBlock *InsertAtEnd)
-    : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) {
+AddrSpaceCastInst::AddrSpaceCastInst(
+  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
+) : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
 }
 
 //===----------------------------------------------------------------------===//
 //                               CmpInst Classes
 //===----------------------------------------------------------------------===//
 
 CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
                  Value *RHS, const Twine &Name, Instruction *InsertBefore,
                  Instruction *FlagsSource)
-    : Instruction(ty, op, OperandTraits<CmpInst>::op_begin(this),
-                  OperandTraits<CmpInst>::operands(this), InsertBefore) {
+  : Instruction(ty, op,
+                OperandTraits<CmpInst>::op_begin(this),
+                OperandTraits<CmpInst>::operands(this),
+                InsertBefore) {
   Op<0>() = LHS;
   Op<1>() = RHS;
   setPredicate((Predicate)predicate);
   setName(Name);
   if (FlagsSource)
     copyIRFlags(FlagsSource);
 }
 
 CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
                  Value *RHS, const Twine &Name, BasicBlock *InsertAtEnd)
-    : Instruction(ty, op, OperandTraits<CmpInst>::op_begin(this),
-                  OperandTraits<CmpInst>::operands(this), InsertAtEnd) {
+  : Instruction(ty, op,
+                OperandTraits<CmpInst>::op_begin(this),
+                OperandTraits<CmpInst>::operands(this),
+                InsertAtEnd) {
   Op<0>() = LHS;
   Op<1>() = RHS;
   setPredicate((Predicate)predicate);
   setName(Name);
 }
 
-CmpInst *CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
-                         const Twine &Name, Instruction *InsertBefore) {
+CmpInst *
+CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
   if (Op == Instruction::ICmp) {
     if (InsertBefore)
-      return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate), S1, S2,
-                          Name);
+      return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate),
+                          S1, S2, Name);
     else
-      return new ICmpInst(CmpInst::Predicate(predicate), S1, S2, Name);
+      return new ICmpInst(CmpInst::Predicate(predicate),
+                          S1, S2, Name);
   }
 
   if (InsertBefore)
-    return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate), S1, S2,
-                        Name);
+    return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate),
+                        S1, S2, Name);
   else
-    return new FCmpInst(CmpInst::Predicate(predicate), S1, S2, Name);
+    return new FCmpInst(CmpInst::Predicate(predicate),
+                        S1, S2, Name);
 }
 
-CmpInst *CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
-                         const Twine &Name, BasicBlock *InsertAtEnd) {
+CmpInst *
+CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
   if (Op == Instruction::ICmp) {
-    return new ICmpInst(*InsertAtEnd, CmpInst::Predicate(predicate), S1, S2,
-                        Name);
+    return new ICmpInst(*InsertAtEnd, CmpInst::Predicate(predicate),
+                        S1, S2, Name);
   }
-  return new FCmpInst(*InsertAtEnd, CmpInst::Predicate(predicate), S1, S2,
-                      Name);
+  return new FCmpInst(*InsertAtEnd, CmpInst::Predicate(predicate),
+                      S1, S2, Name);
 }
 
 void CmpInst::swapOperands() {
   if (ICmpInst *IC = dyn_cast<ICmpInst>(this))
     IC->swapOperands();
   else
     cast<FCmpInst>(this)->swapOperands();
 }
if (ICmpInst::isIntPredicate(P))
     return ICmpInst::isEquality(P);
   if (FCmpInst::isFPPredicate(P))
     return FCmpInst::isEquality(P);
   llvm_unreachable("Unsupported predicate kind");
 }
 
 CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) {
   switch (pred) {
-  default:
-    llvm_unreachable("Unknown cmp predicate!");
-  case ICMP_EQ:
-    return ICMP_NE;
-  case ICMP_NE:
-    return ICMP_EQ;
-  case ICMP_UGT:
-    return ICMP_ULE;
-  case ICMP_ULT:
-    return ICMP_UGE;
-  case ICMP_UGE:
-    return ICMP_ULT;
-  case ICMP_ULE:
-    return ICMP_UGT;
-  case ICMP_SGT:
-    return ICMP_SLE;
-  case ICMP_SLT:
-    return ICMP_SGE;
-  case ICMP_SGE:
-    return ICMP_SLT;
-  case ICMP_SLE:
-    return ICMP_SGT;
-
-  case FCMP_OEQ:
-    return FCMP_UNE;
-  case FCMP_ONE:
-    return FCMP_UEQ;
-  case FCMP_OGT:
-    return FCMP_ULE;
-  case FCMP_OLT:
-    return FCMP_UGE;
-  case FCMP_OGE:
-    return FCMP_ULT;
-  case FCMP_OLE:
-    return FCMP_UGT;
-  case FCMP_UEQ:
-    return FCMP_ONE;
-  case FCMP_UNE:
-    return FCMP_OEQ;
-  case FCMP_UGT:
-    return FCMP_OLE;
-  case FCMP_ULT:
-    return FCMP_OGE;
-  case FCMP_UGE:
-    return FCMP_OLT;
-  case FCMP_ULE:
-    return FCMP_OGT;
-  case FCMP_ORD:
-    return FCMP_UNO;
-  case FCMP_UNO:
-    return FCMP_ORD;
-  case FCMP_TRUE:
-    return FCMP_FALSE;
-  case FCMP_FALSE:
-    return FCMP_TRUE;
+    default: llvm_unreachable("Unknown cmp predicate!");
+    case ICMP_EQ: return ICMP_NE;
+    case ICMP_NE: return ICMP_EQ;
+    case ICMP_UGT: return ICMP_ULE;
+    case ICMP_ULT: return ICMP_UGE;
+    case ICMP_UGE: return ICMP_ULT;
+    case ICMP_ULE: return ICMP_UGT;
+    case ICMP_SGT: return ICMP_SLE;
+    case ICMP_SLT: return ICMP_SGE;
+    case ICMP_SGE: return ICMP_SLT;
+    case ICMP_SLE: return ICMP_SGT;
+
+    case FCMP_OEQ: return FCMP_UNE;
+    case FCMP_ONE: return FCMP_UEQ;
+    case FCMP_OGT: return FCMP_ULE;
+    case FCMP_OLT: return FCMP_UGE;
+    case FCMP_OGE: return FCMP_ULT;
+    case FCMP_OLE: return FCMP_UGT;
+    case FCMP_UEQ: return FCMP_ONE;
+    case FCMP_UNE: return FCMP_OEQ;
+    case FCMP_UGT: return FCMP_OLE;
+    case FCMP_ULT: return FCMP_OGE;
+    case FCMP_UGE: return FCMP_OLT;
+    case FCMP_ULE: return FCMP_OGT;
+    case FCMP_ORD: return FCMP_UNO;
+    case FCMP_UNO: return FCMP_ORD;
+    case FCMP_TRUE: return FCMP_FALSE;
+    case FCMP_FALSE: return FCMP_TRUE;
   }
 }
 
 StringRef CmpInst::getPredicateName(Predicate Pred) {
   switch (Pred) {
-  default:
-    return "unknown";
-  case FCmpInst::FCMP_FALSE:
-    return "false";
-  case FCmpInst::FCMP_OEQ:
-    return "oeq";
-  case FCmpInst::FCMP_OGT:
-    return "ogt";
-  case FCmpInst::FCMP_OGE:
-    return "oge";
-  case FCmpInst::FCMP_OLT:
-    return "olt";
-  case FCmpInst::FCMP_OLE:
-    return "ole";
-  case FCmpInst::FCMP_ONE:
-    return "one";
-  case FCmpInst::FCMP_ORD:
-    return "ord";
-  case FCmpInst::FCMP_UNO:
-    return "uno";
-  case FCmpInst::FCMP_UEQ:
-    return "ueq";
-  case FCmpInst::FCMP_UGT:
-    return "ugt";
-  case FCmpInst::FCMP_UGE:
-    return "uge";
-  case FCmpInst::FCMP_ULT:
-    return "ult";
-  case FCmpInst::FCMP_ULE:
-    return "ule";
-  case FCmpInst::FCMP_UNE:
-    return "une";
-  case FCmpInst::FCMP_TRUE:
-    return "true";
-  case ICmpInst::ICMP_EQ:
-    return "eq";
-  case ICmpInst::ICMP_NE:
-    return "ne";
-  case ICmpInst::ICMP_SGT:
-    return "sgt";
-  case ICmpInst::ICMP_SGE:
-    return "sge";
-  case ICmpInst::ICMP_SLT:
-    return "slt";
-  case ICmpInst::ICMP_SLE:
-    return "sle";
-  case ICmpInst::ICMP_UGT:
-    return "ugt";
-  case ICmpInst::ICMP_UGE:
-    return "uge";
-  case ICmpInst::ICMP_ULT:
-    return "ult";
-  case ICmpInst::ICMP_ULE:
-    return "ule";
+  default:                   return "unknown";
+  case FCmpInst::FCMP_FALSE: return "false";
+  case FCmpInst::FCMP_OEQ:   return "oeq";
+  case FCmpInst::FCMP_OGT:   return "ogt";
+  case FCmpInst::FCMP_OGE:   return "oge";
+  case FCmpInst::FCMP_OLT:   return "olt";
+  case FCmpInst::FCMP_OLE:   return "ole";
+  case FCmpInst::FCMP_ONE:   return "one";
+  case FCmpInst::FCMP_ORD:   return "ord";
+  case FCmpInst::FCMP_UNO:   return "uno";
+  case FCmpInst::FCMP_UEQ:   return "ueq";
+  case FCmpInst::FCMP_UGT:   return "ugt";
+  case FCmpInst::FCMP_UGE:   return "uge";
+  case FCmpInst::FCMP_ULT:   return "ult";
+  case FCmpInst::FCMP_ULE:   return "ule";
+  case FCmpInst::FCMP_UNE:   return "une";
+  case FCmpInst::FCMP_TRUE:  return "true";
+  case ICmpInst::ICMP_EQ:    return "eq";
+  case ICmpInst::ICMP_NE:    return "ne";
+  case ICmpInst::ICMP_SGT:   return "sgt";
+  case ICmpInst::ICMP_SGE:   return "sge";
+  case ICmpInst::ICMP_SLT:   return "slt";
+  case ICmpInst::ICMP_SLE:   return "sle";
+  case ICmpInst::ICMP_UGT:   return "ugt";
+  case ICmpInst::ICMP_UGE:   return "uge";
+  case ICmpInst::ICMP_ULT:   return "ult";
+  case ICmpInst::ICMP_ULE:   return "ule";
   }
 }
 
 ICmpInst::Predicate ICmpInst::getSignedPredicate(Predicate pred) {
   switch (pred) {
-  default:
-    llvm_unreachable("Unknown icmp predicate!");
-  case ICMP_EQ:
-  case ICMP_NE:
-  case ICMP_SGT:
-  case ICMP_SLT:
-  case ICMP_SGE:
-  case ICMP_SLE:
+    default: llvm_unreachable("Unknown icmp predicate!");
+    case ICMP_EQ: case ICMP_NE:
+    case ICMP_SGT: case ICMP_SLT: case ICMP_SGE: case ICMP_SLE:
        return pred;
-  case ICMP_UGT:
-    return ICMP_SGT;
-  case ICMP_ULT:
-    return ICMP_SLT;
-  case ICMP_UGE:
-    return ICMP_SGE;
-  case ICMP_ULE:
-    return ICMP_SLE;
+    case ICMP_UGT: return ICMP_SGT;
+    case ICMP_ULT: return ICMP_SLT;
+    case ICMP_UGE: return ICMP_SGE;
+    case ICMP_ULE: return ICMP_SLE;
   }
 }
 
 ICmpInst::Predicate ICmpInst::getUnsignedPredicate(Predicate pred) {
   switch (pred) {
-  default:
-    llvm_unreachable("Unknown icmp predicate!");
-  case ICMP_EQ:
-  case ICMP_NE:
-  case ICMP_UGT:
-  case ICMP_ULT:
-  case ICMP_UGE:
-  case ICMP_ULE:
+    default: llvm_unreachable("Unknown icmp predicate!");
+    case ICMP_EQ: case ICMP_NE:
+    case ICMP_UGT: case ICMP_ULT: case ICMP_UGE: case ICMP_ULE:
        return pred;
-  case ICMP_SGT:
-    return ICMP_UGT;
-  case ICMP_SLT:
-    return ICMP_ULT;
-  case ICMP_SGE:
-    return ICMP_UGE;
-  case ICMP_SLE:
-    return ICMP_ULE;
+    case ICMP_SGT: return ICMP_UGT;
+    case ICMP_SLT: return ICMP_ULT;
+    case ICMP_SGE: return ICMP_UGE;
+    case ICMP_SLE: return ICMP_ULE;
   }
 }
 
 CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) {
   switch (pred) {
-  default:
-    llvm_unreachable("Unknown cmp predicate!");
-  case ICMP_EQ:
-  case ICMP_NE:
+    default: llvm_unreachable("Unknown cmp predicate!");
+    case ICMP_EQ: case ICMP_NE:
       return pred;
-  case ICMP_SGT:
-    return ICMP_SLT;
-  case ICMP_SLT:
-    return ICMP_SGT;
-  case ICMP_SGE:
-    return ICMP_SLE;
-  case ICMP_SLE:
-    return ICMP_SGE;
-  case ICMP_UGT:
-    return ICMP_ULT;
-  case ICMP_ULT:
-    return ICMP_UGT;
-  case ICMP_UGE:
-    return ICMP_ULE;
-  case ICMP_ULE:
-    return ICMP_UGE;
-
-  case FCMP_FALSE:
-  case FCMP_TRUE:
-  case FCMP_OEQ:
-  case FCMP_ONE:
-  case FCMP_UEQ:
-  case FCMP_UNE:
-  case FCMP_ORD:
-  case FCMP_UNO:
+    case ICMP_SGT: return ICMP_SLT;
+    case ICMP_SLT: return ICMP_SGT;
+    case ICMP_SGE: return ICMP_SLE;
+    case ICMP_SLE: return ICMP_SGE;
+    case ICMP_UGT: return ICMP_ULT;
+    case ICMP_ULT: return ICMP_UGT;
+    case ICMP_UGE: return ICMP_ULE;
+    case ICMP_ULE: return ICMP_UGE;
+
+    case FCMP_FALSE: case FCMP_TRUE:
+    case FCMP_OEQ: case FCMP_ONE:
+    case FCMP_UEQ: case FCMP_UNE:
+    case FCMP_ORD: case FCMP_UNO:
       return pred;
-  case FCMP_OGT:
-    return FCMP_OLT;
-  case FCMP_OLT:
-    return FCMP_OGT;
-  case FCMP_OGE:
-    return FCMP_OLE;
-  case FCMP_OLE:
-    return FCMP_OGE;
-  case FCMP_UGT:
-    return FCMP_ULT;
-  case FCMP_ULT:
-    return FCMP_UGT;
-  case FCMP_UGE:
-    return FCMP_ULE;
-  case FCMP_ULE:
-    return FCMP_UGE;
+    case FCMP_OGT: return FCMP_OLT;
+    case FCMP_OLT: return FCMP_OGT;
+    case FCMP_OGE: return FCMP_OLE;
+    case FCMP_OLE: return FCMP_OGE;
+    case FCMP_UGT: return FCMP_ULT;
+    case FCMP_ULT: return FCMP_UGT;
+    case FCMP_UGE: return FCMP_ULE;
+    case FCMP_ULE: return FCMP_UGE;
   }
 }
 
 bool CmpInst::isNonStrictPredicate(Predicate pred) {
   switch (pred) {
   case ICMP_SGE:
   case ICMP_SLE:
   case ICMP_UGE:
case CmpInst::ICMP_SGT:
     return CmpInst::ICMP_UGT;
   case CmpInst::ICMP_SGE:
     return CmpInst::ICMP_UGE;
   }
 }
 
 bool CmpInst::isUnsigned(Predicate predicate) {
   switch (predicate) {
-  default:
-    return false;
-  case ICmpInst::ICMP_ULT:
-  case ICmpInst::ICMP_ULE:
-  case ICmpInst::ICMP_UGT:
-  case ICmpInst::ICMP_UGE:
-    return true;
+    default: return false;
+    case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE: case ICmpInst::ICMP_UGT:
+    case ICmpInst::ICMP_UGE: return true;
   }
 }
 
 bool CmpInst::isSigned(Predicate predicate) {
   switch (predicate) {
-  default:
-    return false;
-  case ICmpInst::ICMP_SLT:
-  case ICmpInst::ICMP_SLE:
-  case ICmpInst::ICMP_SGT:
-  case ICmpInst::ICMP_SGE:
-    return true;
+    default: return false;
+    case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_SLE: case ICmpInst::ICMP_SGT:
+    case ICmpInst::ICMP_SGE: return true;
   }
 }
 
 bool ICmpInst::compare(const APInt &LHS, const APInt &RHS,
                        ICmpInst::Predicate Pred) {
   assert(ICmpInst::isIntPredicate(Pred) && "Only for integer predicates!");
   switch (Pred) {
   case ICmpInst::Predicate::ICMP_EQ:
CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) {
   if (isUnsigned(pred))
     return getSignedPredicate(pred);
 
   llvm_unreachable("Unknown predicate!");
 }
 
 bool CmpInst::isOrdered(Predicate predicate) {
   switch (predicate) {
-  default:
-    return false;
-  case FCmpInst::FCMP_OEQ:
-  case FCmpInst::FCMP_ONE:
-  case FCmpInst::FCMP_OGT:
-  case FCmpInst::FCMP_OLT:
-  case FCmpInst::FCMP_OGE:
-  case FCmpInst::FCMP_OLE:
-  case FCmpInst::FCMP_ORD:
-    return true;
+    default: return false;
+    case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_ONE: case FCmpInst::FCMP_OGT:
+    case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_OLE:
+    case FCmpInst::FCMP_ORD: return true;
   }
 }
 
 bool CmpInst::isUnordered(Predicate predicate) {
   switch (predicate) {
-  default:
-    return false;
-  case FCmpInst::FCMP_UEQ:
-  case FCmpInst::FCMP_UNE:
-  case FCmpInst::FCMP_UGT:
-  case FCmpInst::FCMP_ULT:
-  case FCmpInst::FCMP_UGE:
-  case FCmpInst::FCMP_ULE:
-  case FCmpInst::FCMP_UNO:
-    return true;
+    default: return false;
+    case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UNE: case FCmpInst::FCMP_UGT:
+    case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_UGE: case FCmpInst::FCMP_ULE:
+    case FCmpInst::FCMP_UNO: return true;
   }
 }
 
 bool CmpInst::isTrueWhenEqual(Predicate predicate) {
-  switch (predicate) {
-  default:
-    return false;
-  case ICMP_EQ:
-  case ICMP_UGE:
-  case ICMP_ULE:
-  case ICMP_SGE:
-  case ICMP_SLE:
-  case FCMP_TRUE:
-  case FCMP_UEQ:
-  case FCMP_UGE:
-  case FCMP_ULE:
-    return true;
+  switch(predicate) {
+    default: return false;
+    case ICMP_EQ:   case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE:
+    case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true;
   }
 }
 
 bool CmpInst::isFalseWhenEqual(Predicate predicate) {
-  switch (predicate) {
-  case ICMP_NE:
-  case ICMP_UGT:
-  case ICMP_ULT:
-  case ICMP_SGT:
-  case ICMP_SLT:
-  case FCMP_FALSE:
-  case FCMP_ONE:
-  case FCMP_OGT:
-  case FCMP_OLT:
-    return true;
-  default:
-    return false;
+  switch(predicate) {
+  case ICMP_NE:    case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT:
+  case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true;
+  default: return false;
   }
 }
 
 bool CmpInst::isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2) {
   // If the predicates match, then we know the first condition implies the
   // second is true.
   if (Pred1 == Pred2)
     return true;

 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
 /// switch on and a default destination.  The number of additional cases can
 /// be specified here to make memory allocation more efficient.  This
 /// constructor can also autoinsert before another instruction.
 SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
                        Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
                   nullptr, 0, InsertBefore) {
-  init(Value, Default, 2 + NumCases * 2);
+  init(Value, Default, 2+NumCases*2);
 }
 
 /// SwitchInst ctor - Create a new switch instruction, specifying a value to
 /// switch on and a default destination.  The number of additional cases can
 /// be specified here to make memory allocation more efficient.  This
 /// constructor also autoinserts at the end of the specified BasicBlock.
 SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
                        BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
                   nullptr, 0, InsertAtEnd) {
-  init(Value, Default, 2 + NumCases * 2);
+  init(Value, Default, 2+NumCases*2);
 }
 
 SwitchInst::SwitchInst(const SwitchInst &SI)
     : Instruction(SI.getType(), Instruction::Switch, nullptr, 0) {
   init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands());
   setNumHungOffUseOperands(SI.getNumOperands());
   Use *OL = getOperandList();
   const Use *InOL = SI.getOperandList();
   for (unsigned i = 2, E = SI.getNumOperands(); i != E; i += 2) {
     OL[i] = InOL[i];
-    OL[i + 1] = InOL[i + 1];
+    OL[i+1] = InOL[i+1];
   }
   SubclassOptionalData = SI.SubclassOptionalData;
 }
 
 /// addCase - Add an entry to the switch instruction...
 ///
 void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
   unsigned NewCaseIdx = getNumCases();
   unsigned OpNo = getNumOperands();
-  if (OpNo + 2 > ReservedSpace)
-    growOperands(); // Get more space!
+  if (OpNo+2 > ReservedSpace)
+    growOperands();  // Get more space!
   // Initialize some new operands.
-  assert(OpNo + 1 < ReservedSpace && "Growing didn't work!");
-  setNumHungOffUseOperands(OpNo + 2);
+  assert(OpNo+1 < ReservedSpace && "Growing didn't work!");
+  setNumHungOffUseOperands(OpNo+2);
   CaseHandle Case(this, NewCaseIdx);
   Case.setValue(OnVal);
   Case.setSuccessor(Dest);
 }
 
 /// removeCase - This method removes the specified case and its successor
 /// from the switch instruction.
 SwitchInst::CaseIt SwitchInst::removeCase(CaseIt I) {
   unsigned idx = I->getCaseIndex();
 
-  assert(2 + idx * 2 < getNumOperands() && "Case index out of range!!!");
+  assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!");
 
   unsigned NumOps = getNumOperands();
   Use *OL = getOperandList();
 
   // Overwrite this case with the end of the list.
   if (2 + (idx + 1) * 2 != NumOps) {
     OL[2 + idx * 2] = OL[NumOps - 2];
     OL[2 + idx * 2 + 1] = OL[NumOps - 1];
   }
 
   // Nuke the last value.
-  OL[NumOps - 2].set(nullptr);
-  OL[NumOps - 2 + 1].set(nullptr);
-  setNumHungOffUseOperands(NumOps - 2);
+  OL[NumOps-2].set(nullptr);
+  OL[NumOps-2+1].set(nullptr);
+  setNumHungOffUseOperands(NumOps-2);
 
   return CaseIt(this, idx);
 }
 
 /// growOperands - grow operands - This grows the operand list in response
 /// to a push_back style of operation.  This grows the number of ops by 3 times.
 ///
 void SwitchInst::growOperands() {
   unsigned e = getNumOperands();
-  unsigned NumOps = e * 3;
+  unsigned NumOps = e*3;
 
   ReservedSpace = NumOps;
   growHungoffUses(ReservedSpace);
 }
 
 MDNode *
 SwitchInstProfUpdateWrapper::getProfBranchWeightsMD(const SwitchInst &SI) {
   if (MDNode *ProfileData = SI.getMetadata(LLVMContext::MD_prof))

 
 //===----------------------------------------------------------------------===//
 //                        IndirectBrInst Implementation
 //===----------------------------------------------------------------------===//
 
 void IndirectBrInst::init(Value *Address, unsigned NumDests) {
   assert(Address && Address->getType()->isPointerTy() &&
          "Address of indirectbr must be a pointer");
-  ReservedSpace = 1 + NumDests;
+  ReservedSpace = 1+NumDests;
   setNumHungOffUseOperands(1);
   allocHungoffUses(ReservedSpace);
 
   Op<0>() = Address;
 }
 
+
 /// growOperands - grow operands - This grows the operand list in response
 /// to a push_back style of operation.  This grows the number of ops by 2 times.
 ///
 void IndirectBrInst::growOperands() {
   unsigned e = getNumOperands();
-  unsigned NumOps = e * 2;
+  unsigned NumOps = e*2;
 
   ReservedSpace = NumOps;
   growHungoffUses(ReservedSpace);
 }
 
 IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
                                Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(Address->getContext()),
for (unsigned i = 0, E = IBI.getNumOperands(); i != E; ++i)
     OL[i] = InOL[i];
   SubclassOptionalData = IBI.SubclassOptionalData;
 }
 
 /// addDestination - Add a destination.
 ///
 void IndirectBrInst::addDestination(BasicBlock *DestBB) {
   unsigned OpNo = getNumOperands();
-  if (OpNo + 1 > ReservedSpace)
-    growOperands(); // Get more space!
+  if (OpNo+1 > ReservedSpace)
+    growOperands();  // Get more space!
   // Initialize some new operands.
   assert(OpNo < ReservedSpace && "Growing didn't work!");
-  setNumHungOffUseOperands(OpNo + 1);
+  setNumHungOffUseOperands(OpNo+1);
   getOperandList()[OpNo] = DestBB;
 }
 
 /// removeDestination - This method removes the specified successor from the
 /// indirectbr instruction.
 void IndirectBrInst::removeDestination(unsigned idx) {
-  assert(idx < getNumOperands() - 1 && "Successor index out of range!");
+  assert(idx < getNumOperands()-1 && "Successor index out of range!");
 
   unsigned NumOps = getNumOperands();
   Use *OL = getOperandList();
 
   // Replace this value with the last one.
-  OL[idx + 1] = OL[NumOps - 1];
+  OL[idx+1] = OL[NumOps-1];
 
   // Nuke the last value.
-  OL[NumOps - 1].set(nullptr);
-  setNumHungOffUseOperands(NumOps - 1);
+  OL[NumOps-1].set(nullptr);
+  setNumHungOffUseOperands(NumOps-1);
 }
 
 //===----------------------------------------------------------------------===//
 //                            FreezeInst Implementation
 //===----------------------------------------------------------------------===//
 
-FreezeInst::FreezeInst(Value *S, const Twine &Name, Instruction *InsertBefore)
+FreezeInst::FreezeInst(Value *S,
+                       const Twine &Name, Instruction *InsertBefore)
     : UnaryInstruction(S->getType(), Freeze, S, InsertBefore) {
   setName(Name);
 }
 
-FreezeInst::FreezeInst(Value *S, const Twine &Name, BasicBlock *InsertAtEnd)
+FreezeInst::FreezeInst(Value *S,
+                       const Twine &Name, BasicBlock *InsertAtEnd)
     : UnaryInstruction(S->getType(), Freeze, S, InsertAtEnd) {
   setName(Name);
 }
 
 //===----------------------------------------------------------------------===//
 //                           cloneImpl() implementations
 //===----------------------------------------------------------------------===//
 

 
 AddrSpaceCastInst *AddrSpaceCastInst::cloneImpl() const {
   return new AddrSpaceCastInst(getOperand(0), getType());
 }
 
 CallInst *CallInst::cloneImpl() const {
   if (hasOperandBundles()) {
     unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo);
-    return new (getNumOperands(), DescriptorBytes) CallInst(*this);
+    return new(getNumOperands(), DescriptorBytes) CallInst(*this);
   }
-  return new (getNumOperands()) CallInst(*this);
+  return  new(getNumOperands()) CallInst(*this);
 }
 
 SelectInst *SelectInst::cloneImpl() const {
   return SelectInst::Create(getOperand(0), getOperand(1), getOperand(2));
 }
 
 VAArgInst *VAArgInst::cloneImpl() const {
   return new VAArgInst(getOperand(0), getType());

 
 PHINode *PHINode::cloneImpl() const { return new PHINode(*this); }
 
 LandingPadInst *LandingPadInst::cloneImpl() const {
   return new LandingPadInst(*this);
 }
 
 ReturnInst *ReturnInst::cloneImpl() const {
-  return new (getNumOperands()) ReturnInst(*this);
+  return new(getNumOperands()) ReturnInst(*this);
 }
 
 BranchInst *BranchInst::cloneImpl() const {
-  return new (getNumOperands()) BranchInst(*this);
+  return new(getNumOperands()) BranchInst(*this);
 }
 
 SwitchInst *SwitchInst::cloneImpl() const { return new SwitchInst(*this); }
 
 IndirectBrInst *IndirectBrInst::cloneImpl() const {
   return new IndirectBrInst(*this);
 }
 
 InvokeInst *InvokeInst::cloneImpl() const {
   if (hasOperandBundles()) {
     unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo);
-    return new (getNumOperands(), DescriptorBytes) InvokeInst(*this);
+    return new(getNumOperands(), DescriptorBytes) InvokeInst(*this);
   }
-  return new (getNumOperands()) InvokeInst(*this);
+  return new(getNumOperands()) InvokeInst(*this);
 }
 
 CallBrInst *CallBrInst::cloneImpl() const {
   if (hasOperandBundles()) {
     unsigned DescriptorBytes = getNumOperandBundles() * sizeof(BundleOpInfo);
     return new (getNumOperands(), DescriptorBytes) CallBrInst(*this);
   }
   return new (getNumOperands()) CallBrInst(*this);

llvm/lib/IR/Verifier.cpp

 void Verifier::visitReturnInst(ReturnInst &RI) {
   Function *F = RI.getParent()->getParent();
   unsigned N = RI.getNumOperands();
   if (F->getReturnType()->isVoidTy())
     Check(N == 0,
           "Found return instr that returns non-void in Function of void "
           "return type!",
           &RI, F->getReturnType());
-  else {
-    llvm::errs() << "F->getReturnType()" << *F->getReturnType() << "\n";
-    llvm::errs() << "RI:" << RI << "\n";
-
+  else
     Check(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
           "Function return type does not match operand "
           "type of return inst!",
           &RI, F->getReturnType());
-  }
+
   // Check to make sure that the return value has necessary properties for
   // terminators...
   visitTerminator(RI);
 }
 
 void Verifier::visitSwitchInst(SwitchInst &SI) {
   Check(SI.getType()->isVoidTy(), "Switch must have void result type!", &SI);
   // Check to make sure that all of the constants in the switch instruction

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

 //
 
 def LLVM_call_intrinsic : LLVM_Op<"call_intrinsic", [Pure]> {
   let arguments = (ins StrAttr:$intrin, Variadic<LLVM_Type>:$args);
   let results = (outs Variadic<LLVM_Type>:$results);
   let llvmBuilder = [{
     llvm::Module *module = builder.GetInsertBlock()->getModule();
     llvm::Intrinsic::ID id = op.getIntrinsicEnum();
-    auto operands = moduleTranslation.lookupValues(opInst.getOperands());
 
     llvm::Function *fn;
     if (llvm::Intrinsic::isOverloaded(id)) {
       fn = llvm::Intrinsic::getDeclaration(module, id, {});
     } else {
       llvm::FunctionType *FT;
-      if (opInst.getResults().size() == 1) {
+      if (opInst.getNumResults() == 1) {
         FT = llvm::Intrinsic::getType(module->getContext(), id, moduleTranslation.convertType(opInst.getResult(0).getType()));
       } else {
         FT = llvm::Intrinsic::getType(module->getContext(), id);
       }
       fn = cast<llvm::Function>(
       module->getOrInsertFunction(llvm::Intrinsic::getName(id), FT).getCallee());
     }
 
-    auto *inst = builder.CreateCall(fn, operands);
-    if (opInst.getNumResults() != 0) {
+    auto *inst = builder.CreateCall(fn, moduleTranslation.lookupValues(opInst.getOperands()));
+    if (opInst.getNumResults() == 1) {
         moduleTranslation.mapValue(op->getResults().front())  = inst;
     }
   }];
   let assemblyFormat = "$intrin `(` $args `)` `:` `(` type($args) `)` `->` type($results) attr-dict";
   let extraClassDeclaration = [{
     llvm::Intrinsic::ID getIntrinsicEnum() {
       return llvm::Function::lookupIntrinsicID(getIntrinAttr());
     }

mlir/lib/Dialect/LLVMIR/CMakeLists.txt

add_mlir_dialect_library(MLIRLLVMDialect
   LINK_LIBS PUBLIC
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIRDataLayoutInterfaces
   MLIRInferTypeOpInterface
   MLIRIR
   MLIRSideEffectInterfaces
   MLIRSupport
   )
 
 add_mlir_dialect_library(MLIRNVVMDialect
   IR/NVVMDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
   MLIRNVVMOpsIncGen
   MLIRNVVMConversionsIncGen
   intrinsics_gen
 
   LINK_COMPONENTS
   AsmParser
   Core
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRLLVMDialect
   MLIRSideEffectInterfaces
   )
 
 add_mlir_dialect_library(MLIRROCDLDialect
   IR/ROCDLDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
   MLIRROCDLOpsIncGen
   MLIRROCDLConversionsIncGen
   intrinsics_gen
 
   LINK_COMPONENTS
   AsmParser
   Core
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRSideEffectInterfaces
   MLIRVectorToLLVM
   )