make clang format happy

Author: spall

clang/lib/CodeGen/CGExpr.cpp

@@ -6360,7 +6360,8 @@ LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
   return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
 }
 
-llvm::Value* CodeGenFunction::PerformLoad(std::pair<Address, llvm::Value *> &GEP) {
+llvm::Value *
+CodeGenFunction::PerformLoad(std::pair<Address, llvm::Value *> &GEP) {
   Address GEPAddress = GEP.first;
   llvm::Value *Idx = GEP.second;
   llvm::Value *V = Builder.CreateLoad(GEPAddress, "load");
@@ -6370,8 +6371,9 @@ llvm::Value* CodeGenFunction::PerformLoad(std::pair<Address, llvm::Value *> &GEP
   return V;
 }
 
-llvm::Value* CodeGenFunction::PerformStore(std::pair<Address, llvm::Value *> &GEP,
-				           llvm::Value *Val) {
+llvm::Value *
+CodeGenFunction::PerformStore(std::pair<Address, llvm::Value *> &GEP,
+                              llvm::Value *Val) {
   Address GEPAddress = GEP.first;
   llvm::Value *Idx = GEP.second;
   if (Idx) {
@@ -6382,20 +6384,21 @@ llvm::Value* CodeGenFunction::PerformStore(std::pair<Address, llvm::Value *> &GE
   }
 }
 
-void CodeGenFunction::FlattenAccessAndType(Address Val, QualType SrcTy,
-			         SmallVector<llvm::Value *, 4> &IdxList,
-			         SmallVector<std::pair<Address, llvm::Value *>, 16> &GEPList,
-				 SmallVector<QualType> &FlatTypes) {
-  llvm::IntegerType *IdxTy = llvm::IntegerType::get(getLLVMContext(),32);
+void CodeGenFunction::FlattenAccessAndType(
+    Address Val, QualType SrcTy, SmallVector<llvm::Value *, 4> &IdxList,
+    SmallVector<std::pair<Address, llvm::Value *>, 16> &GEPList,
+    SmallVector<QualType> &FlatTypes) {
+  llvm::IntegerType *IdxTy = llvm::IntegerType::get(getLLVMContext(), 32);
   if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(SrcTy)) {
     uint64_t Size = CAT->getZExtSize();
-    for(unsigned i = 0; i < Size; i ++) {
+    for (unsigned i = 0; i < Size; i++) {
       // flatten each member of the array
       // add index of this element to index list
       llvm::Value *Idx = llvm::ConstantInt::get(IdxTy, i);
       IdxList.push_back(Idx);
       // recur on this object
-      FlattenAccessAndType(Val, CAT->getElementType(), IdxList, GEPList, FlatTypes);
+      FlattenAccessAndType(Val, CAT->getElementType(), IdxList, GEPList,
+                           FlatTypes);
       // remove index of this element from index list
       IdxList.pop_back();
     }
@@ -6405,7 +6408,7 @@ void CodeGenFunction::FlattenAccessAndType(Address Val, QualType SrcTy,
     // do I need to check if its a cxx record decl?
 
     for (auto fieldIter = Record->field_begin(), fieldEnd = Record->field_end();
-	 fieldIter != fieldEnd; ++fieldIter) {
+         fieldIter != fieldEnd; ++fieldIter) {
       // get the field number
       unsigned FieldNum = RL.getLLVMFieldNo(*fieldIter);
       // can we just do *fieldIter->getFieldIndex();
@@ -6414,16 +6417,16 @@ void CodeGenFunction::FlattenAccessAndType(Address Val, QualType SrcTy,
       IdxList.push_back(Idx);
       // recur on the field
       FlattenAccessAndType(Val, fieldIter->getType(), IdxList, GEPList,
-			   FlatTypes);
+                           FlatTypes);
       // remove index of this element from index list
       IdxList.pop_back();
     }
   } else if (const VectorType *VT = SrcTy->getAs<VectorType>()) {
     llvm::Type *VTy = ConvertTypeForMem(SrcTy);
     CharUnits Align = getContext().getTypeAlignInChars(SrcTy);
-    Address GEP = Builder.CreateInBoundsGEP(Val, IdxList,
-						 VTy, Align, "vector.gep");
-    for(unsigned i = 0; i < VT->getNumElements(); i ++) {
+    Address GEP =
+        Builder.CreateInBoundsGEP(Val, IdxList, VTy, Align, "vector.gep");
+    for (unsigned i = 0; i < VT->getNumElements(); i++) {
       // add index to the list
       llvm::Value *Idx = llvm::ConstantInt::get(IdxTy, i);
       // create gep. no need to recur since its always a scalar
@@ -6435,8 +6438,7 @@ void CodeGenFunction::FlattenAccessAndType(Address Val, QualType SrcTy,
     // create a gep
     llvm::Type *Ty = ConvertTypeForMem(SrcTy);
     CharUnits Align = getContext().getTypeAlignInChars(SrcTy);
-    Address GEP = Builder.CreateInBoundsGEP(Val, IdxList,
-						     Ty, Align,  "gep");
+    Address GEP = Builder.CreateInBoundsGEP(Val, IdxList, Ty, Align, "gep");
     GEPList.push_back({GEP, NULL});
     FlatTypes.push_back(SrcTy);
   }

clang/lib/CodeGen/CGExprAgg.cpp

@@ -491,50 +491,45 @@ static bool isTrivialFiller(Expr *E) {
   return false;
 }
 
-
-
 // emit a flat cast where the RHS is a scalar, including vector
 static void EmitHLSLScalarFlatCast(CodeGenFunction &CGF, Address DestVal,
-			    QualType DestTy, llvm::Value *SrcVal,
-			    QualType SrcTy, SourceLocation Loc) {
+                                   QualType DestTy, llvm::Value *SrcVal,
+                                   QualType SrcTy, SourceLocation Loc) {
   // Flatten our destination
   SmallVector<QualType> DestTypes; // Flattened type
   SmallVector<llvm::Value *, 4> IdxList;
   SmallVector<std::pair<Address, llvm::Value *>, 16> StoreGEPList;
   // ^^ Flattened accesses to DestVal we want to store into
-  CGF.FlattenAccessAndType(DestVal, DestTy, IdxList, StoreGEPList,
-		       DestTypes);
+  CGF.FlattenAccessAndType(DestVal, DestTy, IdxList, StoreGEPList, DestTypes);
 
   if (const VectorType *VT = SrcTy->getAs<VectorType>()) {
     SrcTy = VT->getElementType();
     assert(StoreGEPList.size() <= VT->getNumElements() &&
-	   "Cannot perform HLSL flat cast when vector source \
+           "Cannot perform HLSL flat cast when vector source \
            object has less elements than flattened destination \
            object.");
-      for(unsigned i = 0; i < StoreGEPList.size(); i ++) {
-        llvm::Value *Load = CGF.Builder.CreateExtractElement(SrcVal, i,
-							     "vec.load");
-	llvm::Value *Cast = CGF.EmitScalarConversion(Load, SrcTy,
-						     DestTypes[i],
-						     Loc);
-	CGF.PerformStore(StoreGEPList[i], Cast);
-      }
-      return;
+    for (unsigned i = 0; i < StoreGEPList.size(); i++) {
+      llvm::Value *Load =
+          CGF.Builder.CreateExtractElement(SrcVal, i, "vec.load");
+      llvm::Value *Cast =
+          CGF.EmitScalarConversion(Load, SrcTy, DestTypes[i], Loc);
+      CGF.PerformStore(StoreGEPList[i], Cast);
+    }
+    return;
   }
   llvm_unreachable("HLSL Flat cast doesn't handle splatting.");
 }
 
 // emit a flat cast where the RHS is an aggregate
 static void EmitHLSLAggregateFlatCast(CodeGenFunction &CGF, Address DestVal,
-			       QualType DestTy, Address SrcVal,
-			       QualType SrcTy, SourceLocation Loc) {
+                                      QualType DestTy, Address SrcVal,
+                                      QualType SrcTy, SourceLocation Loc) {
   // Flatten our destination
   SmallVector<QualType> DestTypes; // Flattened type
   SmallVector<llvm::Value *, 4> IdxList;
   SmallVector<std::pair<Address, llvm::Value *>, 16> StoreGEPList;
   // ^^ Flattened accesses to DestVal we want to store into
-  CGF.FlattenAccessAndType(DestVal, DestTy, IdxList, StoreGEPList,
-		       DestTypes);
+  CGF.FlattenAccessAndType(DestVal, DestTy, IdxList, StoreGEPList, DestTypes);
   // Flatten our src
   SmallVector<QualType> SrcTypes; // Flattened type
   SmallVector<std::pair<Address, llvm::Value *>, 16> LoadGEPList;
@@ -543,14 +538,14 @@ static void EmitHLSLAggregateFlatCast(CodeGenFunction &CGF, Address DestVal,
   CGF.FlattenAccessAndType(SrcVal, SrcTy, IdxList, LoadGEPList, SrcTypes);
 
   assert(StoreGEPList.size() <= LoadGEPList.size() &&
-	 "Cannot perform HLSL flat cast when flattened source object \
+         "Cannot perform HLSL flat cast when flattened source object \
           has less elements than flattened destination object.");
   // apply casts to what we load from LoadGEPList
   // and store result in Dest
-  for(unsigned i = 0; i < StoreGEPList.size(); i ++) {
+  for (unsigned i = 0; i < StoreGEPList.size(); i++) {
     llvm::Value *Load = CGF.PerformLoad(LoadGEPList[i]);
-    llvm::Value *Cast = CGF.EmitScalarConversion(Load, SrcTypes[i],
-						 DestTypes[i], Loc);
+    llvm::Value *Cast =
+        CGF.EmitScalarConversion(Load, SrcTypes[i], DestTypes[i], Loc);
     CGF.PerformStore(StoreGEPList[i], Cast);
   }
 }
@@ -967,11 +962,12 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
       EmitHLSLScalarFlatCast(CGF, DestVal, DestTy, SrcVal, SrcTy, Loc);
     } else { // RHS is an aggregate
       assert(RV.isAggregate() &&
-	     "Can't perform HLSL Aggregate cast on a complex type.");
+             "Can't perform HLSL Aggregate cast on a complex type.");
       Address SrcVal = RV.getAggregateAddress();
       EmitHLSLAggregateFlatCast(CGF, DestVal, DestTy, SrcVal, SrcTy, Loc);
     }
-    break; }
+    break;
+  }
   case CK_NoOp:
   case CK_UserDefinedConversion:
   case CK_ConstructorConversion:

clang/lib/CodeGen/CGExprScalar.cpp

@@ -2264,31 +2264,32 @@ bool CodeGenFunction::ShouldNullCheckClassCastValue(const CastExpr *CE) {
 
 // RHS is an aggregate type
 static Value *EmitHLSLAggregateFlatCast(CodeGenFunction &CGF, Address RHSVal,
-					QualType RHSTy, QualType LHSTy,
-					SourceLocation Loc) {
+                                        QualType RHSTy, QualType LHSTy,
+                                        SourceLocation Loc) {
   SmallVector<llvm::Value *, 4> IdxList;
   SmallVector<std::pair<Address, llvm::Value *>, 16> LoadGEPList;
   SmallVector<QualType> SrcTypes; // Flattened type
   CGF.FlattenAccessAndType(RHSVal, RHSTy, IdxList, LoadGEPList, SrcTypes);
   // LHS is either a vector or a builtin?
   // if its a vector create a temp alloca to store into and return that
   if (auto *VecTy = LHSTy->getAs<VectorType>()) {
-    llvm::Value *V = CGF.Builder.CreateLoad(CGF.CreateIRTemp(LHSTy, "flatcast.tmp"));
+    llvm::Value *V =
+        CGF.Builder.CreateLoad(CGF.CreateIRTemp(LHSTy, "flatcast.tmp"));
     // write to V.
-    for(unsigned i = 0; i < VecTy->getNumElements(); i ++) {
+    for (unsigned i = 0; i < VecTy->getNumElements(); i++) {
       llvm::Value *Load = CGF.PerformLoad(LoadGEPList[i]);
-      llvm::Value *Cast = CGF.EmitScalarConversion(Load, SrcTypes[i],
-						   VecTy->getElementType(), Loc);
+      llvm::Value *Cast = CGF.EmitScalarConversion(
+          Load, SrcTypes[i], VecTy->getElementType(), Loc);
       V = CGF.Builder.CreateInsertElement(V, Cast, i);
     }
     return V;
   }
   // i its a builtin just do an extract element or load.
   assert(LHSTy->isBuiltinType() &&
-	 "Destination type must be a vector or builtin type.");
+         "Destination type must be a vector or builtin type.");
   // TODO add asserts about things being long enough
-  return CGF.EmitScalarConversion(CGF.PerformLoad(LoadGEPList[0]),
-				  LHSTy, SrcTypes[0], Loc);
+  return CGF.EmitScalarConversion(CGF.PerformLoad(LoadGEPList[0]), LHSTy,
+                                  SrcTypes[0], Loc);
 }
 
 // VisitCastExpr - Emit code for an explicit or implicit cast.  Implicit casts

clang/lib/CodeGen/CodeGenFunction.h

@@ -4360,11 +4360,12 @@ class CodeGenFunction : public CodeGenTypeCache {
   LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e);
 
   llvm::Value *PerformLoad(std::pair<Address, llvm::Value *> &GEP);
-  llvm::Value *PerformStore(std::pair<Address, llvm::Value *> &GEP, llvm::Value *Val);
-  void FlattenAccessAndType(Address Val, QualType SrcTy,
-			    SmallVector<llvm::Value *, 4> &IdxList,
-			    SmallVector<std::pair<Address, llvm::Value *>, 16> &GEPList,
-			    SmallVector<QualType> &FlatTypes);
+  llvm::Value *PerformStore(std::pair<Address, llvm::Value *> &GEP,
+                            llvm::Value *Val);
+  void FlattenAccessAndType(
+      Address Val, QualType SrcTy, SmallVector<llvm::Value *, 4> &IdxList,
+      SmallVector<std::pair<Address, llvm::Value *>, 16> &GEPList,
+      SmallVector<QualType> &FlatTypes);
 
   llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
                               const ObjCIvarDecl *Ivar);

clang/lib/Sema/SemaCast.cpp

@@ -23,9 +23,9 @@
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/Initialization.h"
+#include "clang/Sema/SemaHLSL.h"
 #include "clang/Sema/SemaObjC.h"
 #include "clang/Sema/SemaRISCV.h"
-#include "clang/Sema/SemaHLSL.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include <set>
@@ -2780,7 +2780,9 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
   if (Self.getLangOpts().HLSL &&
       Self.HLSL().CanPerformAggregateCast(SrcExpr.get(), DestType)) {
     if (SrcTy->isConstantArrayType())
-      SrcExpr = Self.ImpCastExprToType(SrcExpr.get(), Self.Context.getArrayParameterType(SrcTy), CK_HLSLArrayRValue, VK_PRValue, nullptr, CCK);
+      SrcExpr = Self.ImpCastExprToType(
+          SrcExpr.get(), Self.Context.getArrayParameterType(SrcTy),
+          CK_HLSLArrayRValue, VK_PRValue, nullptr, CCK);
     Kind = CK_HLSLAggregateCast;
     return;
   }

clang/lib/Sema/SemaHLSL.cpp

@@ -2530,7 +2530,7 @@ bool SemaHLSL::CanPerformAggregateCast(Expr *Src, QualType DestTy) {
   QualType SrcTy = Src->getType();
   if (SrcTy->isScalarType()) // always a splat and this cast doesn't handle that
     return false;
-  
+
   if ((DestTy->isScalarType() || DestTy->isVectorType()) &&
       (SrcTy->isScalarType() || SrcTy->isVectorType()))
     return false;
@@ -2540,11 +2540,12 @@ bool SemaHLSL::CanPerformAggregateCast(Expr *Src, QualType DestTy) {
   llvm::SmallVector<QualType> SrcTypes;
   BuildFlattenedTypeList(SrcTy, SrcTypes);
 
-  // Usually the size of SrcTypes must be greater than or equal to the size of DestTypes.
+  // Usually the size of SrcTypes must be greater than or equal to the size of
+  // DestTypes.
   if (SrcTypes.size() >= DestTypes.size()) {
 
     unsigned i;
-    for(i = 0; i < DestTypes.size() && i < SrcTypes.size(); i ++) {
+    for (i = 0; i < DestTypes.size() && i < SrcTypes.size(); i++) {
       if (!CanPerformScalarCast(SrcTypes[i], DestTypes[i])) {
         return false;
       }

clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

@@ -522,7 +522,7 @@ void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
       case CK_ToUnion:
       case CK_MatrixCast:
       case CK_VectorSplat:
-    case CK_HLSLAggregateCast:
+      case CK_HLSLAggregateCast:
       case CK_HLSLVectorTruncation: {
         QualType resultType = CastE->getType();
         if (CastE->isGLValue())