Reflow comments and some minor whitespace fixups.

llvm-svn: 81337

1 files changed, 182 insertions, 185 deletions

diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp
index 8732dc91309..3dc95902af7 100644
--- a/clang/lib/CodeGen/CGExprScalar.cpp
+++ b/clang/lib/CodeGen/CGExprScalar.cpp
@@ -53,10 +53,10 @@ class VISIBILITY_HIDDEN ScalarExprEmitter
 public:
 
   ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
-    : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 
+    : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
       VMContext(cgf.getLLVMContext()) {
   }
-  
+
   //===--------------------------------------------------------------------===//
   //                               Utilities
   //===--------------------------------------------------------------------===//
@@ -73,25 +73,25 @@ public:
   Value *EmitLoadOfLValue(LValue LV, QualType T) {
     return CGF.EmitLoadOfLValue(LV, T).getScalarVal();
   }
-    
+
   /// EmitLoadOfLValue - Given an expression with complex type that represents a
   /// value l-value, this method emits the address of the l-value, then loads
   /// and returns the result.
   Value *EmitLoadOfLValue(const Expr *E) {
     return EmitLoadOfLValue(EmitLValue(E), E->getType());
   }
-    
+
   /// EmitConversionToBool - Convert the specified expression value to a
   /// boolean (i1) truth value.  This is equivalent to "Val != 0".
   Value *EmitConversionToBool(Value *Src, QualType DstTy);
-    
+
   /// EmitScalarConversion - Emit a conversion from the specified type to the
   /// specified destination type, both of which are LLVM scalar types.
   Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy);
 
   /// EmitComplexToScalarConversion - Emit a conversion from the specified
-  /// complex type to the specified destination type, where the destination
-  /// type is an LLVM scalar type.
+  /// complex type to the specified destination type, where the destination type
+  /// is an LLVM scalar type.
   Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
                                        QualType SrcTy, QualType DstTy);
 
@@ -133,26 +133,26 @@ public:
   }
   Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E);
   Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
-    llvm::Value *V = 
+    llvm::Value *V =
       llvm::ConstantInt::get(llvm::Type::getInt32Ty(CGF.getLLVMContext()),
                              CGF.GetIDForAddrOfLabel(E->getLabel()));
-    
+
     return Builder.CreateIntToPtr(V, ConvertType(E->getType()));
   }
-    
+
   // l-values.
   Value *VisitDeclRefExpr(DeclRefExpr *E) {
     if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(E->getDecl()))
       return llvm::ConstantInt::get(VMContext, EC->getInitVal());
     return EmitLoadOfLValue(E);
   }
-  Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 
-    return CGF.EmitObjCSelectorExpr(E); 
+  Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
+    return CGF.EmitObjCSelectorExpr(E);
   }
-  Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 
-    return CGF.EmitObjCProtocolExpr(E); 
+  Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
+    return CGF.EmitObjCProtocolExpr(E);
   }
-  Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 
+  Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
     return EmitLoadOfLValue(E);
   }
   Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
@@ -177,7 +177,7 @@ public:
   Value *VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
      return EmitLValue(E).getAddress();
   }
-    
+
   Value *VisitPredefinedExpr(Expr *E) { return EmitLValue(E).getAddress(); }
 
   Value *VisitInitListExpr(InitListExpr *E) {
@@ -185,24 +185,24 @@ public:
     (void)Ignore;
     assert (Ignore == false && "init list ignored");
     unsigned NumInitElements = E->getNumInits();
-    
+
     if (E->hadArrayRangeDesignator()) {
       CGF.ErrorUnsupported(E, "GNU array range designator extension");
     }
 
-    const llvm::VectorType *VType = 
+    const llvm::VectorType *VType =
       dyn_cast<llvm::VectorType>(ConvertType(E->getType()));
-    
+
     // We have a scalar in braces. Just use the first element.
-    if (!VType) 
+    if (!VType)
       return Visit(E->getInit(0));
-    
+
     unsigned NumVectorElements = VType->getNumElements();
     const llvm::Type *ElementType = VType->getElementType();
 
     // Emit individual vector element stores.
     llvm::Value *V = llvm::UndefValue::get(VType);
-    
+
     // Emit initializers
     unsigned i;
     for (i = 0; i < NumInitElements; ++i) {
@@ -211,7 +211,7 @@ public:
         llvm::ConstantInt::get(llvm::Type::getInt32Ty(CGF.getLLVMContext()), i);
       V = Builder.CreateInsertElement(V, NewV, Idx);
     }
-    
+
     // Emit remaining default initializers
     for (/* Do not initialize i*/; i < NumVectorElements; ++i) {
       Value *Idx =
@@ -219,22 +219,22 @@ public:
       llvm::Value *NewV = llvm::Constant::getNullValue(ElementType);
       V = Builder.CreateInsertElement(V, NewV, Idx);
     }
-    
+
     return V;
   }
-  
+
   Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
     return llvm::Constant::getNullValue(ConvertType(E->getType()));
   }
   Value *VisitCastExpr(const CastExpr *E) {
     if (E->getCastKind() == CastExpr::CK_UserDefinedConversion) {
-      if (const CXXFunctionalCastExpr *CXXFExpr = 
+      if (const CXXFunctionalCastExpr *CXXFExpr =
             dyn_cast<CXXFunctionalCastExpr>(E))
         return CGF.EmitCXXFunctionalCastExpr(CXXFExpr).getScalarVal();
-      assert(isa<CStyleCastExpr>(E) && 
+      assert(isa<CStyleCastExpr>(E) &&
              "VisitCastExpr - missing CStyleCastExpr");
     }
-      
+
     // Make sure to evaluate VLA bounds now so that we have them for later.
     if (E->getType()->isVariablyModifiedType())
       CGF.EmitVLASize(E->getType());
@@ -246,14 +246,14 @@ public:
   Value *VisitCallExpr(const CallExpr *E) {
     if (E->getCallReturnType()->isReferenceType())
       return EmitLoadOfLValue(E);
-    
+
     return CGF.EmitCallExpr(E).getScalarVal();
   }
 
   Value *VisitStmtExpr(const StmtExpr *E);
 
   Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E);
-  
+
   // Unary Operators.
   Value *VisitPrePostIncDec(const UnaryOperator *E, bool isInc, bool isPre);
   Value *VisitUnaryPostDec(const UnaryOperator *E) {
@@ -286,15 +286,15 @@ public:
     return Visit(E->getSubExpr());
   }
   Value *VisitUnaryOffsetOf(const UnaryOperator *E);
-    
+
   // C++
   Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
     return Visit(DAE->getExpr());
   }
   Value *VisitCXXThisExpr(CXXThisExpr *TE) {
     return CGF.LoadCXXThis();
-  }      
-    
+  }
+
   Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
     return CGF.EmitCXXExprWithTemporaries(E).getScalarVal();
   }
@@ -305,17 +305,17 @@ public:
     CGF.EmitCXXDeleteExpr(E);
     return 0;
   }
-  
+
   Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) {
     // C++ [expr.pseudo]p1:
-    //   The result shall only be used as the operand for the function call 
+    //   The result shall only be used as the operand for the function call
     //   operator (), and the result of such a call has type void. The only
     //   effect is the evaluation of the postfix-expression before the dot or
     //   arrow.
     CGF.EmitScalarExpr(E->getBase());
     return 0;
   }
-    
+
   // Binary Operators.
   Value *EmitMul(const BinOpInfo &Ops) {
     if (CGF.getContext().getLangOptions().OverflowChecking
@@ -382,7 +382,7 @@ public:
   VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ);
   VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE);
 #undef VISITCOMP
-  
+
   Value *VisitBinAssign     (const BinaryOperator *E);
 
   Value *VisitBinLAnd       (const BinaryOperator *E);
@@ -408,24 +408,24 @@ public:
 /// boolean (i1) truth value.  This is equivalent to "Val != 0".
 Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
   assert(SrcType->isCanonical() && "EmitScalarConversion strips typedefs");
-  
+
   if (SrcType->isRealFloatingType()) {
     // Compare against 0.0 for fp scalars.
     llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType());
     return Builder.CreateFCmpUNE(Src, Zero, "tobool");
   }
-  
+
   if (SrcType->isMemberPointerType()) {
     // FIXME: This is ABI specific.
-    
+
     // Compare against -1.
     llvm::Value *NegativeOne = llvm::Constant::getAllOnesValue(Src->getType());
     return Builder.CreateICmpNE(Src, NegativeOne, "tobool");
   }
-  
+
   assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
          "Unknown scalar type to convert");
-  
+
   // Because of the type rules of C, we often end up computing a logical value,
   // then zero extending it to int, then wanting it as a logical value again.
   // Optimize this common case.
@@ -441,7 +441,7 @@ Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
       return Result;
     }
   }
-  
+
   // Compare against an integer or pointer null.
   llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType());
   return Builder.CreateICmpNE(Src, Zero, "tobool");
@@ -454,32 +454,31 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
   SrcType = CGF.getContext().getCanonicalType(SrcType);
   DstType = CGF.getContext().getCanonicalType(DstType);
   if (SrcType == DstType) return Src;
-  
+
   if (DstType->isVoidType()) return 0;
-  
+
   llvm::LLVMContext &VMContext = CGF.getLLVMContext();
 
   // Handle conversions to bool first, they are special: comparisons against 0.
   if (DstType->isBooleanType())
     return EmitConversionToBool(Src, SrcType);
-  
+
   const llvm::Type *DstTy = ConvertType(DstType);
 
   // Ignore conversions like int -> uint.
   if (Src->getType() == DstTy)
     return Src;
 
-  // Handle pointer conversions next: pointers can only be converted
-  // to/from other pointers and integers. Check for pointer types in
-  // terms of LLVM, as some native types (like Obj-C id) may map to a
-  // pointer type.
+  // Handle pointer conversions next: pointers can only be converted to/from
+  // other pointers and integers. Check for pointer types in terms of LLVM, as
+  // some native types (like Obj-C id) may map to a pointer type.
   if (isa<llvm::PointerType>(DstTy)) {
     // The source value may be an integer, or a pointer.
     if (isa<llvm::PointerType>(Src->getType())) {
       // Some heavy lifting for derived to base conversion.
-      if (const CXXRecordDecl *ClassDecl = 
+      if (const CXXRecordDecl *ClassDecl =
             SrcType->getCXXRecordDeclForPointerType())
-        if (const CXXRecordDecl *BaseClassDecl = 
+        if (const CXXRecordDecl *BaseClassDecl =
               DstType->getCXXRecordDeclForPointerType())
           Src = CGF.AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl);
       return Builder.CreateBitCast(Src, DstTy, "conv");
@@ -487,7 +486,7 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
     assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?");
     // First, convert to the correct width so that we control the kind of
     // extension.
-    const llvm::Type *MiddleTy = 
+    const llvm::Type *MiddleTy =
           llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth);
     bool InputSigned = SrcType->isSignedIntegerType();
     llvm::Value* IntResult =
@@ -495,13 +494,13 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
     // Then, cast to pointer.
     return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
   }
-  
+
   if (isa<llvm::PointerType>(Src->getType())) {
     // Must be an ptr to int cast.
     assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
     return Builder.CreatePtrToInt(Src, DstTy, "conv");
   }
-  
+
   // A scalar can be splatted to an extended vector of the same element type
   if (DstType->isExtVectorType() && !SrcType->isVectorType()) {
     // Cast the scalar to element type
@@ -520,7 +519,7 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
     for (unsigned i = 0; i < NumElements; i++)
       Args.push_back(llvm::ConstantInt::get(
                                         llvm::Type::getInt32Ty(VMContext), 0));
-    
+
     llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements);
     llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat");
     return Yay;
@@ -530,7 +529,7 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
   if (isa<llvm::VectorType>(Src->getType()) ||
       isa<llvm::VectorType>(DstTy))
     return Builder.CreateBitCast(Src, DstTy, "conv");
-      
+
   // Finally, we have the arithmetic types: real int/float.
   if (isa<llvm::IntegerType>(Src->getType())) {
     bool InputSigned = SrcType->isSignedIntegerType();
@@ -541,7 +540,7 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
     else
       return Builder.CreateUIToFP(Src, DstTy, "conv");
   }
-  
+
   assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
   if (isa<llvm::IntegerType>(DstTy)) {
     if (DstType->isSignedIntegerType())
@@ -557,15 +556,15 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
     return Builder.CreateFPExt(Src, DstTy, "conv");
 }
 
-/// EmitComplexToScalarConversion - Emit a conversion from the specified
-/// complex type to the specified destination type, where the destination
-/// type is an LLVM scalar type.
+/// EmitComplexToScalarConversion - Emit a conversion from the specified complex
+/// type to the specified destination type, where the destination type is an
+/// LLVM scalar type.
 Value *ScalarExprEmitter::
 EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
                               QualType SrcTy, QualType DstTy) {
   // Get the source element type.
   SrcTy = SrcTy->getAsComplexType()->getElementType();
-  
+
   // Handle conversions to bool first, they are special: comparisons against 0.
   if (DstTy->isBooleanType()) {
     //  Complex != 0  -> (Real != 0) | (Imag != 0)
@@ -573,11 +572,11 @@ EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
     Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy);
     return Builder.CreateOr(Src.first, Src.second, "tobool");
   }
-  
+
   // C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
   // the imaginary part of the complex value is discarded and the value of the
   // real part is converted according to the conversion rules for the
-  // corresponding real type. 
+  // corresponding real type.
   return EmitScalarConversion(Src.first, SrcTy, DstTy);
 }
 
@@ -613,14 +612,14 @@ Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   // so we can't get it as an lvalue.
   if (!E->getBase()->getType()->isVectorType())
     return EmitLoadOfLValue(E);
-  
+
   // Handle the vector case.  The base must be a vector, the index must be an
   // integer value.
   Value *Base = Visit(E->getBase());
   Value *Idx  = Visit(E->getIdx());
   bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType();
   Idx = Builder.CreateIntCast(Idx,
-                              llvm::Type::getInt32Ty(CGF.getLLVMContext()), 
+                              llvm::Type::getInt32Ty(CGF.getLLVMContext()),
                               IdxSigned,
                               "vecidxcast");
   return Builder.CreateExtractElement(Base, Idx, "vecext");
@@ -633,7 +632,7 @@ Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy,
                                        CastExpr::CastKind Kind) {
   if (!DestTy->isVoidType())
     TestAndClearIgnoreResultAssign();
-  
+
   switch (Kind) {
   default:
     break;
@@ -644,7 +643,7 @@ Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy,
   case CastExpr::CK_ArrayToPointerDecay: {
     assert(E->getType()->isArrayType() &&
            "Array to pointer decay must have array source type!");
-    
+
     Value *V = EmitLValue(E).getAddress();  // Bitfields can't be arrays.
 
     // Note that VLA pointers are always decayed, so we don't need to do
@@ -656,7 +655,7 @@ Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy,
              "Expected pointer to array");
       V = Builder.CreateStructGEP(V, 0, "arraydecay");
     }
-    
+
     // The resultant pointer type can be implicitly casted to other pointer
     // types as well (e.g. void*) and can be implicitly converted to integer.
     const llvm::Type *DestLTy = ConvertType(DestTy);
@@ -669,20 +668,20 @@ Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy,
       }
     }
     return V;
-  }      
+  }
   case CastExpr::CK_NullToMemberPointer:
     return CGF.CGM.EmitNullConstant(DestTy);
   }
-  
+
   // Handle cases where the source is an non-complex type.
-  
+
   if (!CGF.hasAggregateLLVMType(E->getType())) {
     Value *Src = Visit(const_cast<Expr*>(E));
 
     // Use EmitScalarConversion to perform the conversion.
     return EmitScalarConversion(Src, E->getType(), DestTy);
   }
-  
+
   if (E->getType()->isAnyComplexType()) {
     // Handle cases where the source is a complex type.
     bool IgnoreImag = true;
@@ -727,7 +726,7 @@ Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
   Value *InVal = CGF.EmitLoadOfLValue(LV, ValTy).getScalarVal();
 
   llvm::LLVMContext &VMContext = CGF.getLLVMContext();
-  
+
   int AmountVal = isInc ? 1 : -1;
 
   if (ValTy->isPointerType() &&
@@ -737,26 +736,26 @@ Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
   }
 
   Value *NextVal;
-  if (const llvm::PointerType *PT = 
+  if (const llvm::PointerType *PT =
          dyn_cast<llvm::PointerType>(InVal->getType())) {
     llvm::Constant *Inc =
       llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), AmountVal);
     if (!isa<llvm::FunctionType>(PT->getElementType())) {
       QualType PTEE = ValTy->getPointeeType();
-      if (const ObjCInterfaceType *OIT = 
+      if (const ObjCInterfaceType *OIT =
           dyn_cast<ObjCInterfaceType>(PTEE)) {
         // Handle interface types, which are not represented with a concrete type.
         int size = CGF.getContext().getTypeSize(OIT) / 8;
         if (!isInc)
           size = -size;
         Inc = llvm::ConstantInt::get(Inc->getType(), size);
-        const llvm::Type *i8Ty = 
+        const llvm::Type *i8Ty =
           llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
         InVal = Builder.CreateBitCast(InVal, i8Ty);
         NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr");
         llvm::Value *lhs = LV.getAddress();
         lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty));
-        LV = LValue::MakeAddr(lhs, ValTy.getCVRQualifiers(), 
+        LV = LValue::MakeAddr(lhs, ValTy.getCVRQualifiers(),
                               CGF.getContext().getObjCGCAttrKind(ValTy));
       } else
         NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec");
@@ -785,11 +784,11 @@ Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
   } else {
     // Add the inc/dec to the real part.
     if (InVal->getType() == llvm::Type::getFloatTy(VMContext))
-      NextVal = 
-        llvm::ConstantFP::get(VMContext, 
+      NextVal =
+        llvm::ConstantFP::get(VMContext,
                               llvm::APFloat(static_cast<float>(AmountVal)));
     else if (InVal->getType() == llvm::Type::getDoubleTy(VMContext))
-      NextVal = 
+      NextVal =
         llvm::ConstantFP::get(VMContext,
                               llvm::APFloat(static_cast<double>(AmountVal)));
     else {
@@ -801,7 +800,7 @@ Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
     }
     NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec");
   }
-  
+
   // Store the updated result through the lvalue.
   if (LV.isBitfield())
     CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy,
@@ -832,12 +831,12 @@ Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
 Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
   // Compare operand to zero.
   Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
-  
+
   // Invert value.
   // TODO: Could dynamically modify easy computations here.  For example, if
   // the operand is an icmp ne, turn into icmp eq.
   BoolVal = Builder.CreateNot(BoolVal, "lnot");
-  
+
   // ZExt result to the expr type.
   return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
 }
@@ -848,7 +847,7 @@ Value *
 ScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
   QualType TypeToSize = E->getTypeOfArgument();
   if (E->isSizeOf()) {
-    if (const VariableArrayType *VAT = 
+    if (const VariableArrayType *VAT =
           CGF.getContext().getAsVariableArrayType(TypeToSize)) {
       if (E->isArgumentType()) {
         // sizeof(type) - make sure to emit the VLA size.
@@ -858,13 +857,13 @@ ScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
         // VLA, it is evaluated.
         CGF.EmitAnyExpr(E->getArgumentExpr());
       }
-      
+
       return CGF.GetVLASize(VAT);
     }
   }
 
-  // If this isn't sizeof(vla), the result must be constant; use the
-  // constant folding logic so we don't have to duplicate it here.
+  // If this isn't sizeof(vla), the result must be constant; use the constant
+  // folding logic so we don't have to duplicate it here.
   Expr::EvalResult Result;
   E->Evaluate(Result, CGF.getContext());
   return llvm::ConstantInt::get(VMContext, Result.Val.getInt());
@@ -880,7 +879,7 @@ Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
   Expr *Op = E->getSubExpr();
   if (Op->getType()->isAnyComplexType())
     return CGF.EmitComplexExpr(Op, true, false, true, false).second;
-  
+
   // __imag on a scalar returns zero.  Emit the subexpr to ensure side
   // effects are evaluated, but not the actual value.
   if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid)
@@ -919,10 +918,10 @@ Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
   BinOpInfo OpInfo;
 
   if (E->getComputationResultType()->isAnyComplexType()) {
-    // This needs to go through the complex expression emitter, but
-    // it's a tad complicated to do that... I'm leaving it out for now.
-    // (Note that we do actually need the imaginary part of the RHS for
-    // multiplication and division.)
+    // This needs to go through the complex expression emitter, but it's a tad
+    // complicated to do that... I'm leaving it out for now.  (Note that we do
+    // actually need the imaginary part of the RHS for multiplication and
+    // division.)
     CGF.ErrorUnsupported(E, "complex compound assignment");
     return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
   }
@@ -937,17 +936,17 @@ Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
   OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy);
   OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy,
                                     E->getComputationLHSType());
-  
+
   // Expand the binary operator.
   Value *Result = (this->*Func)(OpInfo);
-  
+
   // Convert the result back to the LHS type.
   Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy);
 
-  // Store the result value into the LHS lvalue. Bit-fields are
-  // handled specially because the result is altered by the store,
-  // i.e., [C99 6.5.16p1] 'An assignment expression has the value of
-  // the left operand after the assignment...'.
+  // Store the result value into the LHS lvalue. Bit-fields are handled
+  // specially because the result is altered by the store, i.e., [C99 6.5.16p1]
+  // 'An assignment expression has the value of the left operand after the
+  // assignment...'.
   if (LHSLV.isBitfield()) {
     if (!LHSLV.isVolatileQualified()) {
       CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy,
@@ -1029,7 +1028,7 @@ Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) {
   Builder.SetInsertPoint(overflowBB);
 
   // Handler is:
-  // long long *__overflow_handler)(long long a, long long b, char op, 
+  // long long *__overflow_handler)(long long a, long long b, char op,
   // char width)
   std::vector<const llvm::Type*> handerArgTypes;
   handerArgTypes.push_back(llvm::Type::getInt64Ty(VMContext));
@@ -1047,13 +1046,13 @@ Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) {
       Builder.CreateSExt(Ops.LHS, llvm::Type::getInt64Ty(VMContext)),
       Builder.CreateSExt(Ops.RHS, llvm::Type::getInt64Ty(VMContext)),
       llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), OpID),
-      llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 
+      llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext),
         cast<llvm::IntegerType>(opTy)->getBitWidth()));
 
   handlerResult = Builder.CreateTrunc(handlerResult, opTy);
 
   Builder.CreateBr(continueBB);
-  
+
   // Set up the continuation
   Builder.SetInsertPoint(continueBB);
   // Get the correct result
@@ -1070,7 +1069,7 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
     if (CGF.getContext().getLangOptions().OverflowChecking &&
         Ops.Ty->isSignedIntegerType())
       return EmitOverflowCheckedBinOp(Ops);
-    
+
     if (Ops.LHS->getType()->isFPOrFPVector())
       return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add");
 
@@ -1089,7 +1088,7 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
   Value *Ptr, *Idx;
   Expr *IdxExp;
   const PointerType *PT = Ops.E->getLHS()->getType()->getAs<PointerType>();
-  const ObjCObjectPointerType *OPT = 
+  const ObjCObjectPointerType *OPT =
     Ops.E->getLHS()->getType()->getAsObjCObjectPointerType();
   if (PT || OPT) {
     Ptr = Ops.LHS;
@@ -1116,10 +1115,9 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
       Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
   }
   const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType();
-  // Handle interface types, which are not represented with a concrete
-  // type.
+  // Handle interface types, which are not represented with a concrete type.
   if (const ObjCInterfaceType *OIT = dyn_cast<ObjCInterfaceType>(ElementType)) {
-    llvm::Value *InterfaceSize = 
+    llvm::Value *InterfaceSize =
       llvm::ConstantInt::get(Idx->getType(),
                              CGF.getContext().getTypeSize(OIT) / 8);
     Idx = Builder.CreateMul(Idx, InterfaceSize);
@@ -1128,19 +1126,19 @@ Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
     Value *Casted = Builder.CreateBitCast(Ptr, i8Ty);
     Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr");
     return Builder.CreateBitCast(Res, Ptr->getType());
-  } 
+  }
 
-  // Explicitly handle GNU void* and function pointer arithmetic
-  // extensions. The GNU void* casts amount to no-ops since our void*
-  // type is i8*, but this is future proof.
+  // Explicitly handle GNU void* and function pointer arithmetic extensions. The
+  // GNU void* casts amount to no-ops since our void* type is i8*, but this is
+  // future proof.
   if (ElementType->isVoidType() || ElementType->isFunctionType()) {
     const llvm::Type *i8Ty =
         llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
     Value *Casted = Builder.CreateBitCast(Ptr, i8Ty);
     Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr");
     return Builder.CreateBitCast(Res, Ptr->getType());
-  } 
-  
+  }
+
   return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr");
 }
 
@@ -1182,38 +1180,37 @@ Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) {
     }
     Idx = Builder.CreateNeg(Idx, "sub.ptr.neg");
 
-    // Handle interface types, which are not represented with a concrete
-    // type.
-    if (const ObjCInterfaceType *OIT = 
+    // Handle interface types, which are not represented with a concrete type.
+    if (const ObjCInterfaceType *OIT =
         dyn_cast<ObjCInterfaceType>(LHSElementType)) {
-      llvm::Value *InterfaceSize = 
+      llvm::Value *InterfaceSize =
         llvm::ConstantInt::get(Idx->getType(),
                                CGF.getContext().getTypeSize(OIT) / 8);
       Idx = Builder.CreateMul(Idx, InterfaceSize);
-      const llvm::Type *i8Ty = 
+      const llvm::Type *i8Ty =
         llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
       Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty);
       Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr");
       return Builder.CreateBitCast(Res, Ops.LHS->getType());
-    } 
+    }
 
     // Explicitly handle GNU void* and function pointer arithmetic
-    // extensions. The GNU void* casts amount to no-ops since our
-    // void* type is i8*, but this is future proof.
+    // extensions. The GNU void* casts amount to no-ops since our void* type is
+    // i8*, but this is future proof.
     if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) {
       const llvm::Type *i8Ty =
         llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
       Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty);
       Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr");
       return Builder.CreateBitCast(Res, Ops.LHS->getType());
-    } 
-      
+    }
+
     return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr");
   } else {
     // pointer - pointer
     Value *LHS = Ops.LHS;
     Value *RHS = Ops.RHS;
-  
+
     uint64_t ElementSize;
 
     // Handle GCC extension for pointer arithmetic on void* and function pointer
@@ -1223,19 +1220,19 @@ Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) {
     } else {
       ElementSize = CGF.getContext().getTypeSize(LHSElementType) / 8;
     }
-    
+
     const llvm::Type *ResultType = ConvertType(Ops.Ty);
     LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast");
     RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
     Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
-    
+
     // Optimize out the shift for element size of 1.
     if (ElementSize == 1)
       return BytesBetween;
 
     // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since
-    // pointer difference in C is only defined in the case where both
-    // operands are pointing to elements of an array.
+    // pointer difference in C is only defined in the case where both operands
+    // are pointing to elements of an array.
     Value *BytesPerElt = llvm::ConstantInt::get(ResultType, ElementSize);
     return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div");
   }
@@ -1247,7 +1244,7 @@ Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
   Value *RHS = Ops.RHS;
   if (Ops.LHS->getType() != RHS->getType())
     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
-  
+
   return Builder.CreateShl(Ops.LHS, RHS, "shl");
 }
 
@@ -1257,7 +1254,7 @@ Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
   Value *RHS = Ops.RHS;
   if (Ops.LHS->getType() != RHS->getType())
     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
-  
+
   if (Ops.Ty->isUnsignedIntegerType())
     return Builder.CreateLShr(Ops.LHS, RHS, "shr");
   return Builder.CreateAShr(Ops.LHS, RHS, "shr");
@@ -1271,7 +1268,7 @@ Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
   if (!LHSTy->isAnyComplexType()) {
     Value *LHS = Visit(E->getLHS());
     Value *RHS = Visit(E->getRHS());
-    
+
     if (LHS->getType()->isFPOrFPVector()) {
       Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc,
                                   LHS, RHS, "cmp");
@@ -1288,14 +1285,14 @@ Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
     // vector integer type and return it (don't convert to bool).
     if (LHSTy->isVectorType())
       return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
-    
+
   } else {
     // Complex Comparison: can only be an equality comparison.
     CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
     CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
-    
+
     QualType CETy = LHSTy->getAsComplexType()->getElementType();
-    
+
     Value *ResultR, *ResultI;
     if (CETy->isRealFloatingType()) {
       ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
@@ -1310,7 +1307,7 @@ Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
       ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
                                    LHS.second, RHS.second, "cmp.i");
     }
-    
+
     if (E->getOpcode() == BinaryOperator::EQ) {
       Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
     } else {
@@ -1330,7 +1327,7 @@ Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
   // improve codegen just a little.
   Value *RHS = Visit(E->getRHS());
   LValue LHS = EmitLValue(E->getLHS());
-  
+
   // Store the value into the LHS.  Bit-fields are handled specially
   // because the result is altered by the store, i.e., [C99 6.5.16p1]
   // 'An assignment expression has the value of the left operand after
@@ -1358,12 +1355,12 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
       // ZExt result to int.
       return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "land.ext");
     }
-    
+
     // 0 && RHS: If it is safe, just elide the RHS, and return 0.
     if (!CGF.ContainsLabel(E->getRHS()))
       return llvm::Constant::getNullValue(CGF.LLVMIntTy);
   }
-  
+
   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
   llvm::BasicBlock *RHSBlock  = CGF.createBasicBlock("land.rhs");
 
@@ -1379,12 +1376,12 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
   for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
        PI != PE; ++PI)
     PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
-  
+
   CGF.PushConditionalTempDestruction();
   CGF.EmitBlock(RHSBlock);
   Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
   CGF.PopConditionalTempDestruction();
-  
+
   // Reaquire the RHS block, as there may be subblocks inserted.
   RHSBlock = Builder.GetInsertBlock();
 
@@ -1392,7 +1389,7 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
   // into the phi node for the edge with the value of RHSCond.
   CGF.EmitBlock(ContBlock);
   PN->addIncoming(RHSCond, RHSBlock);
-  
+
   // ZExt result to int.
   return Builder.CreateZExt(PN, CGF.LLVMIntTy, "land.ext");
 }
@@ -1406,15 +1403,15 @@ Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
       // ZExt result to int.
       return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "lor.ext");
     }
-    
+
     // 1 || RHS: If it is safe, just elide the RHS, and return 1.
     if (!CGF.ContainsLabel(E->getRHS()))
       return llvm::ConstantInt::get(CGF.LLVMIntTy, 1);
   }
-  
+
   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
-  
+
   // Branch on the LHS first.  If it is true, go to the success (cont) block.
   CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock);
 
@@ -1433,17 +1430,17 @@ Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
   // Emit the RHS condition as a bool value.
   CGF.EmitBlock(RHSBlock);
   Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
-  
+
   CGF.PopConditionalTempDestruction();
-  
+
   // Reaquire the RHS block, as there may be subblocks inserted.
   RHSBlock = Builder.GetInsertBlock();
-  
+
   // Emit an unconditional branch from this block to ContBlock.  Insert an entry
   // into the phi node for the edge with the value of RHSCond.
   CGF.EmitBlock(ContBlock);
   PN->addIncoming(RHSCond, RHSBlock);
-  
+
   // ZExt result to int.
   return Builder.CreateZExt(PN, CGF.LLVMIntTy, "lor.ext");
 }
@@ -1465,19 +1462,19 @@ Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
 static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E) {
   if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
     return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr());
-  
+
   // TODO: Allow anything we can constant fold to an integer or fp constant.
   if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) ||
       isa<FloatingLiteral>(E))
     return true;
-  
+
   // Non-volatile automatic variables too, to get "cond ? X : Y" where
   // X and Y are local variables.
   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
     if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
       if (VD->hasLocalStorage() && !VD->getType().isVolatileQualified())
         return true;
-  
+
   return false;
 }
 
@@ -1491,7 +1488,7 @@ VisitConditionalOperator(const ConditionalOperator *E) {
     Expr *Live = E->getLHS(), *Dead = E->getRHS();
     if (Cond == -1)
       std::swap(Live, Dead);
-    
+
     // If the dead side doesn't have labels we need, and if the Live side isn't
     // the gnu missing ?: extension (which we could handle, but don't bother
     // to), just emit the Live part.
@@ -1499,8 +1496,8 @@ VisitConditionalOperator(const ConditionalOperator *E) {
         Live)                                   // Live part isn't missing.
       return Visit(Live);
   }
-  
-  
+
+
   // If this is a really simple expression (like x ? 4 : 5), emit this as a
   // select instead of as control flow.  We can only do this if it is cheap and
   // safe to evaluate the LHS and RHS unconditionally.
@@ -1511,15 +1508,15 @@ VisitConditionalOperator(const ConditionalOperator *E) {
     llvm::Value *RHS = Visit(E->getRHS());
     return Builder.CreateSelect(CondV, LHS, RHS, "cond");
   }
-  
-  
+
+
   llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
   Value *CondVal = 0;
 
-  // If we don't have the GNU missing condition extension, emit a branch on
-  // bool the normal way.
+  // If we don't have the GNU missing condition extension, emit a branch on bool
+  // the normal way.
   if (E->getLHS()) {
     // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for
     // the branch on bool.
@@ -1529,7 +1526,7 @@ VisitConditionalOperator(const ConditionalOperator *E) {
     // convert it to bool the hard way.  We do this explicitly because we need
     // the unconverted value for the missing middle value of the ?:.
     CondVal = CGF.EmitScalarExpr(E->getCond());
-    
+
     // In some cases, EmitScalarConversion will delete the "CondVal" expression
     // if there are no extra uses (an optimization).  Inhibit this by making an
     // extra dead use, because we're going to add a use of CondVal later.  We
@@ -1537,7 +1534,7 @@ VisitConditionalOperator(const ConditionalOperator *E) {
     // away.  This leaves dead code, but the ?: extension isn't common.
     new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder",
                           Builder.GetInsertBlock());
-    
+
     Value *CondBoolVal =
       CGF.EmitScalarConversion(CondVal, E->getCond()->getType(),
                                CGF.getContext().BoolTy);
@@ -1546,33 +1543,33 @@ VisitConditionalOperator(const ConditionalOperator *E) {
 
   CGF.PushConditionalTempDestruction();
   CGF.EmitBlock(LHSBlock);
-  
+
   // Handle the GNU extension for missing LHS.
   Value *LHS;
   if (E->getLHS())
     LHS = Visit(E->getLHS());
   else    // Perform promotions, to handle cases like "short ?: int"
     LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType());
-  
+
   CGF.PopConditionalTempDestruction();
   LHSBlock = Builder.GetInsertBlock();
   CGF.EmitBranch(ContBlock);
-  
+
   CGF.PushConditionalTempDestruction();
   CGF.EmitBlock(RHSBlock);
-  
+
   Value *RHS = Visit(E->getRHS());
   CGF.PopConditionalTempDestruction();
   RHSBlock = Builder.GetInsertBlock();
   CGF.EmitBranch(ContBlock);
-  
+
   CGF.EmitBlock(ContBlock);
-  
+
   if (!LHS || !RHS) {
     assert(E->getType()->isVoidType() && "Non-void value should have a value");
     return 0;
   }
-  
+
   // Create a PHI node for the real part.
   llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond");
   PN->reserveOperandSpace(2);
@@ -1590,7 +1587,7 @@ Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
   llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
 
   // If EmitVAArg fails, we fall back to the LLVM instruction.
-  if (!ArgPtr) 
+  if (!ArgPtr)
     return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType()));
 
   // FIXME Volatility.
@@ -1605,12 +1602,12 @@ Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) {
 //                         Entry Point into this File
 //===----------------------------------------------------------------------===//
 
-/// EmitScalarExpr - Emit the computation of the specified expression of
-/// scalar type, ignoring the result.
+/// EmitScalarExpr - Emit the computation of the specified expression of scalar
+/// type, ignoring the result.
 Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
   assert(E && !hasAggregateLLVMType(E->getType()) &&
          "Invalid scalar expression to emit");
-  
+
   return ScalarExprEmitter(*this, IgnoreResultAssign)
     .Visit(const_cast<Expr*>(E));
 }
@@ -1624,9 +1621,9 @@ Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy,
   return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy);
 }
 
-/// EmitComplexToScalarConversion - Emit a conversion from the specified
-/// complex type to the specified destination type, where the destination
-/// type is an LLVM scalar type.
+/// EmitComplexToScalarConversion - Emit a conversion from the specified complex
+/// type to the specified destination type, where the destination type is an
+/// LLVM scalar type.
 Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
                                                       QualType SrcTy,
                                                       QualType DstTy) {
@@ -1639,40 +1636,40 @@ Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
 Value *CodeGenFunction::EmitShuffleVector(Value* V1, Value *V2, ...) {
   assert(V1->getType() == V2->getType() &&
          "Vector operands must be of the same type");
-  unsigned NumElements = 
+  unsigned NumElements =
     cast<llvm::VectorType>(V1->getType())->getNumElements();
-  
+
   va_list va;
   va_start(va, V2);
-  
+
   llvm::SmallVector<llvm::Constant*, 16> Args;
   for (unsigned i = 0; i < NumElements; i++) {
     int n = va_arg(va, int);
-    assert(n >= 0 && n < (int)NumElements * 2 && 
+    assert(n >= 0 && n < (int)NumElements * 2 &&
            "Vector shuffle index out of bounds!");
     Args.push_back(llvm::ConstantInt::get(
                                          llvm::Type::getInt32Ty(VMContext), n));
   }
-  
+
   const char *Name = va_arg(va, const char *);
   va_end(va);
-  
+
   llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements);
-  
+
   return Builder.CreateShuffleVector(V1, V2, Mask, Name);
 }
 
-llvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals, 
+llvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals,
                                          unsigned NumVals, bool isSplat) {
   llvm::Value *Vec
     = llvm::UndefValue::get(llvm::VectorType::get(Vals[0]->getType(), NumVals));
-  
+
   for (unsigned i = 0, e = NumVals; i != e; ++i) {
     llvm::Value *Val = isSplat ? Vals[0] : Vals[i];
     llvm::Value *Idx = llvm::ConstantInt::get(
                                           llvm::Type::getInt32Ty(VMContext), i);
     Vec = Builder.CreateInsertElement(Vec, Val, Idx, "tmp");
   }
-  
-  return Vec;  
+
+  return Vec;
 }