Fix coding style violations

ahatanak · ahatanak · commit d0021eaedd31 · 2024-07-26T17:09:50.000-07:00
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -3468,8 +3468,8 @@ class Sema final : public SemaBase {
     PADAK_ExtraDiscPtrAuth,
   };
 
-  bool checkPointerAuthDiscriminatorArg(Expr *arg, PointerAuthDiscArgKind kind,
-                                        unsigned &intVal);
+  bool checkPointerAuthDiscriminatorArg(Expr *Arg, PointerAuthDiscArgKind Kind,
+                                        unsigned &IntVal);
 
   /// Diagnose function specifiers on a declaration of an identifier that
   /// does not identify a function.
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
@@ -2823,21 +2823,21 @@ void CXXNameMangler::mangleQualifiers(Qualifiers Quals, const DependentAddressSp
     mangleVendorQualifier("__unaligned");
 
   // __ptrauth.  Note that this is parameterized.
-  if (auto ptrauth = Quals.getPointerAuth()) {
+  if (auto PtrAuth = Quals.getPointerAuth()) {
     mangleVendorQualifier("__ptrauth");
     // For now, since we only allow non-dependent arguments, we can just
     // inline the mangling of those arguments as literals.  We treat the
     // key and extra-discriminator arguments as 'unsigned int' and the
     // address-discriminated argument as 'bool'.
     Out << "I"
            "Lj"
-        << ptrauth.getKey()
+        << PtrAuth.getKey()
         << "E"
            "Lb"
-        << unsigned(ptrauth.isAddressDiscriminated())
+        << unsigned(PtrAuth.isAddressDiscriminated())
         << "E"
            "Lj"
-        << ptrauth.getExtraDiscriminator()
+        << PtrAuth.getExtraDiscriminator()
         << "E"
            "E";
   }
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
@@ -2470,8 +2470,8 @@ bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
       return false;
 
-  if (auto pointerAuth = getPointerAuth())
-    if (!pointerAuth.isEmptyWhenPrinted(Policy))
+  if (auto PointerAuth = getPointerAuth())
+    if (!PointerAuth.isEmptyWhenPrinted(Policy))
       return false;
 
   return true;
@@ -2580,12 +2580,12 @@ void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
     }
   }
 
-  if (auto pointerAuth = getPointerAuth()) {
+  if (auto PointerAuth = getPointerAuth()) {
     if (addSpace)
       OS << ' ';
     addSpace = true;
 
-    pointerAuth.print(OS, Policy);
+    PointerAuth.print(OS, Policy);
   }
 
   if (appendSpaceIfNonEmpty && addSpace)
diff --git a/clang/lib/CodeGen/CGDecl.cpp b/clang/lib/CodeGen/CGDecl.cpp
@@ -795,17 +795,17 @@ void CodeGenFunction::EmitScalarInit(const Expr *init, const ValueDecl *D,
                                      LValue lvalue, bool capturedByInit) {
   Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
   if (!lifetime) {
-    llvm::Value *value;
-    if (auto ptrauth = lvalue.getQuals().getPointerAuth()) {
-      value = EmitPointerAuthQualify(ptrauth, init, lvalue.getAddress());
+    llvm::Value *Value;
+    if (auto PtrAuth = lvalue.getQuals().getPointerAuth()) {
+      Value = EmitPointerAuthQualify(PtrAuth, init, lvalue.getAddress());
       lvalue.getQuals().removePointerAuth();
     } else {
-      value = EmitScalarExpr(init);
+      Value = EmitScalarExpr(init);
     }
     if (capturedByInit)
       drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
-    EmitNullabilityCheck(lvalue, value, init->getExprLoc());
-    EmitStoreThroughLValue(RValue::get(value), lvalue, true);
+    EmitNullabilityCheck(lvalue, Value, init->getExprLoc());
+    EmitStoreThroughLValue(RValue::get(Value), lvalue, true);
     return;
   }
 
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
@@ -2191,10 +2191,10 @@ RValue CodeGenFunction::EmitLoadOfAnyValue(LValue LV, AggValueSlot Slot,
 /// returning the rvalue.
 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
   // Load from __ptrauth.
-  if (auto ptrauth = LV.getQuals().getPointerAuth()) {
+  if (auto PtrAuth = LV.getQuals().getPointerAuth()) {
     LV.getQuals().removePointerAuth();
     auto value = EmitLoadOfLValue(LV, Loc).getScalarVal();
-    return RValue::get(EmitPointerAuthUnqualify(ptrauth, value, LV.getType(),
+    return RValue::get(EmitPointerAuthUnqualify(PtrAuth, value, LV.getType(),
                                                 LV.getAddress(),
                                                 /*known nonnull*/ false));
   }
@@ -2427,8 +2427,8 @@ void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
   }
 
   // Handle __ptrauth qualification by re-signing the value.
-  if (auto pointerAuth = Dst.getQuals().getPointerAuth()) {
-    Src = RValue::get(EmitPointerAuthQualify(pointerAuth, Src.getScalarVal(),
+  if (auto PointerAuth = Dst.getQuals().getPointerAuth()) {
+    Src = RValue::get(EmitPointerAuthQualify(PointerAuth, Src.getScalarVal(),
                                              Dst.getType(), Dst.getAddress(),
                                              /*known nonnull*/ false));
   }
@@ -5574,21 +5574,21 @@ CGCallee CodeGenFunction::EmitCallee(const Expr *E) {
     // Try to remember the original __ptrauth qualifier for loads of
     // function pointers.
     if (ICE->getCastKind() == CK_LValueToRValue) {
-      auto subExpr = ICE->getSubExpr();
-      if (auto ptrType = subExpr->getType()->getAs<PointerType>()) {
-        auto result = EmitOrigPointerRValue(E);
+      auto *SubExpr = ICE->getSubExpr();
+      if (auto *PtrType = SubExpr->getType()->getAs<PointerType>()) {
+        auto Result = EmitOrigPointerRValue(E);
 
-        QualType functionType = ptrType->getPointeeType();
-        assert(functionType->isFunctionType());
+        QualType FunctionType = PtrType->getPointeeType();
+        assert(FunctionType->isFunctionType());
 
         GlobalDecl GD;
         if (const auto *VD =
                 dyn_cast_or_null<VarDecl>(E->getReferencedDeclOfCallee())) {
           GD = GlobalDecl(VD);
         }
-        CGCalleeInfo calleeInfo(functionType->getAs<FunctionProtoType>(), GD);
-        CGCallee callee(calleeInfo, result.first, result.second);
-        return callee;
+        CGCalleeInfo CalleeInfo(FunctionType->getAs<FunctionProtoType>(), GD);
+        CGCallee Callee(CalleeInfo, Result.first, Result.second);
+        return Callee;
       }
     }
 
@@ -5654,12 +5654,12 @@ LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
 
   switch (getEvaluationKind(E->getType())) {
   case TEK_Scalar: {
-    if (auto ptrauth = E->getLHS()->getType().getPointerAuth()) {
+    if (auto PtrAuth = E->getLHS()->getType().getPointerAuth()) {
       LValue LV = EmitCheckedLValue(E->getLHS(), TCK_Store);
       LValue CopiedLV = LV;
       CopiedLV.getQuals().removePointerAuth();
       llvm::Value *RV =
-          EmitPointerAuthQualify(ptrauth, E->getRHS(), CopiedLV.getAddress());
+          EmitPointerAuthQualify(PtrAuth, E->getRHS(), CopiedLV.getAddress());
       EmitNullabilityCheck(CopiedLV, RV, E->getExprLoc());
       EmitStoreThroughLValue(RValue::get(RV), CopiedLV);
       return LV;
diff --git a/clang/lib/CodeGen/CGExprConstant.cpp b/clang/lib/CodeGen/CGExprConstant.cpp
@@ -2068,9 +2068,9 @@ llvm::Constant *ConstantLValueEmitter::tryEmit() {
   }
 
   // Apply pointer-auth signing from the destination type.
-  if (auto pointerAuth = DestType.getPointerAuth()) {
+  if (auto PointerAuth = DestType.getPointerAuth()) {
     if (!result.HasDestPointerAuth) {
-      value = Emitter.tryEmitConstantSignedPointer(value, pointerAuth);
+      value = Emitter.tryEmitConstantSignedPointer(value, PointerAuth);
       if (!value)
         return nullptr;
     }
@@ -2119,9 +2119,9 @@ ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
       return CGM.GetWeakRefReference(D).getPointer();
 
     auto PtrAuthSign = [&](llvm::Constant *C) {
-      if (auto pointerAuth = DestType.getPointerAuth()) {
+      if (auto PointerAuth = DestType.getPointerAuth()) {
         C = applyOffset(C);
-        C = Emitter.tryEmitConstantSignedPointer(C, pointerAuth);
+        C = Emitter.tryEmitConstantSignedPointer(C, PointerAuth);
         return ConstantLValue(C, /*applied offset*/ true, /*signed*/ true);
       }
 
diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp
@@ -2203,15 +2203,15 @@ static bool isDeclRefKnownNonNull(CodeGenFunction &CGF, const ValueDecl *D) {
 static bool isLValueKnownNonNull(CodeGenFunction &CGF, const Expr *E) {
   E = E->IgnoreParens();
 
-  if (auto UO = dyn_cast<UnaryOperator>(E)) {
+  if (auto *UO = dyn_cast<UnaryOperator>(E)) {
     if (UO->getOpcode() == UO_Deref) {
       return CGF.isPointerKnownNonNull(UO->getSubExpr());
     }
   }
 
-  if (auto DRE = dyn_cast<DeclRefExpr>(E)) {
+  if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
     return isDeclRefKnownNonNull(CGF, DRE->getDecl());
-  } else if (auto ME = dyn_cast<MemberExpr>(E)) {
+  } else if (auto *ME = dyn_cast<MemberExpr>(E)) {
     if (isa<FieldDecl>(ME->getMemberDecl()))
       return true;
     return isDeclRefKnownNonNull(CGF, ME->getMemberDecl());
@@ -2230,13 +2230,13 @@ bool CodeGenFunction::isPointerKnownNonNull(const Expr *E) {
   if (isa<CXXThisExpr>(E))
     return true;
 
-  if (auto UO = dyn_cast<UnaryOperator>(E)) {
+  if (auto *UO = dyn_cast<UnaryOperator>(E)) {
     if (UO->getOpcode() == UO_AddrOf) {
       return isLValueKnownNonNull(*this, UO->getSubExpr());
     }
   }
 
-  if (auto CE = dyn_cast<CastExpr>(E)) {
+  if (auto *CE = dyn_cast<CastExpr>(E)) {
     if (CE->getCastKind() == CK_FunctionToPointerDecay ||
         CE->getCastKind() == CK_ArrayToPointerDecay) {
       return isLValueKnownNonNull(*this, CE->getSubExpr());
@@ -4850,17 +4850,17 @@ Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
   Value *RHS;
   LValue LHS;
 
-  if (auto ptrauth = E->getLHS()->getType().getPointerAuth()) {
+  if (auto PtrAuth = E->getLHS()->getType().getPointerAuth()) {
     LValue LV = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
     LV.getQuals().removePointerAuth();
     llvm::Value *RV =
-        CGF.EmitPointerAuthQualify(ptrauth, E->getRHS(), LV.getAddress());
+        CGF.EmitPointerAuthQualify(PtrAuth, E->getRHS(), LV.getAddress());
     CGF.EmitNullabilityCheck(LV, RV, E->getExprLoc());
     CGF.EmitStoreThroughLValue(RValue::get(RV), LV);
 
     if (Ignore)
       return nullptr;
-    RV = CGF.EmitPointerAuthUnqualify(ptrauth, RV, LV.getType(),
+    RV = CGF.EmitPointerAuthUnqualify(PtrAuth, RV, LV.getType(),
                                       LV.getAddress(), /*nonnull*/ false);
     return RV;
   }
diff --git a/clang/lib/CodeGen/CGPointerAuth.cpp b/clang/lib/CodeGen/CGPointerAuth.cpp
@@ -194,99 +194,99 @@ CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForType(QualType T) {
 }
 
 static std::pair<llvm::Value *, CGPointerAuthInfo>
-emitLoadOfOrigPointerRValue(CodeGenFunction &CGF, const LValue &lv,
-                            SourceLocation loc) {
-  auto value = CGF.EmitLoadOfScalar(lv, loc);
-  CGPointerAuthInfo authInfo;
-  if (auto ptrauth = lv.getQuals().getPointerAuth()) {
-    authInfo = CGF.EmitPointerAuthInfo(ptrauth, lv.getAddress());
+emitLoadOfOrigPointerRValue(CodeGenFunction &CGF, const LValue &LV,
+                            SourceLocation Loc) {
+  auto *Value = CGF.EmitLoadOfScalar(LV, Loc);
+  CGPointerAuthInfo AuthInfo;
+  if (auto PtrAuth = LV.getQuals().getPointerAuth()) {
+    AuthInfo = CGF.EmitPointerAuthInfo(PtrAuth, LV.getAddress());
   } else {
-    authInfo = getPointerAuthInfoForType(CGF.CGM, lv.getType());
+    AuthInfo = getPointerAuthInfoForType(CGF.CGM, LV.getType());
   }
-  return {value, authInfo};
+  return {Value, AuthInfo};
 }
 
 std::pair<llvm::Value *, CGPointerAuthInfo>
 CodeGenFunction::EmitOrigPointerRValue(const Expr *E) {
   assert(E->getType()->isSignableType());
 
   E = E->IgnoreParens();
-  if (auto load = dyn_cast<ImplicitCastExpr>(E)) {
-    if (load->getCastKind() == CK_LValueToRValue) {
-      E = load->getSubExpr()->IgnoreParens();
+  if (auto *Load = dyn_cast<ImplicitCastExpr>(E)) {
+    if (Load->getCastKind() == CK_LValueToRValue) {
+      E = Load->getSubExpr()->IgnoreParens();
 
       // We're semantically required to not emit loads of certain DREs naively.
-      if (auto refExpr = dyn_cast<DeclRefExpr>(const_cast<Expr *>(E))) {
-        if (auto result = tryEmitAsConstant(refExpr)) {
+      if (auto *RefExpr = dyn_cast<DeclRefExpr>(const_cast<Expr *>(E))) {
+        if (auto Result = tryEmitAsConstant(RefExpr)) {
           // Fold away a use of an intermediate variable.
-          if (!result.isReference())
-            return {result.getValue(),
-                    getPointerAuthInfoForType(CGM, refExpr->getType())};
+          if (!Result.isReference())
+            return {Result.getValue(),
+                    getPointerAuthInfoForType(CGM, RefExpr->getType())};
 
           // Fold away a use of an intermediate reference.
-          auto lv = result.getReferenceLValue(*this, refExpr);
-          return emitLoadOfOrigPointerRValue(*this, lv, refExpr->getLocation());
+          auto LV = Result.getReferenceLValue(*this, RefExpr);
+          return emitLoadOfOrigPointerRValue(*this, LV, RefExpr->getLocation());
         }
       }
 
       // Otherwise, load and use the pointer
-      auto lv = EmitCheckedLValue(E, CodeGenFunction::TCK_Load);
-      return emitLoadOfOrigPointerRValue(*this, lv, E->getExprLoc());
+      auto LV = EmitCheckedLValue(E, CodeGenFunction::TCK_Load);
+      return emitLoadOfOrigPointerRValue(*this, LV, E->getExprLoc());
     }
   }
 
   // Emit direct references to functions without authentication.
-  if (auto DRE = dyn_cast<DeclRefExpr>(E)) {
-    if (auto FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
+  if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
+    if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
       return {CGM.getRawFunctionPointer(FD), CGPointerAuthInfo()};
     }
-  } else if (auto ME = dyn_cast<MemberExpr>(E)) {
-    if (auto FD = dyn_cast<FunctionDecl>(ME->getMemberDecl())) {
+  } else if (auto *ME = dyn_cast<MemberExpr>(E)) {
+    if (auto *FD = dyn_cast<FunctionDecl>(ME->getMemberDecl())) {
       EmitIgnoredExpr(ME->getBase());
       return {CGM.getRawFunctionPointer(FD), CGPointerAuthInfo()};
     }
   }
 
   // Fallback: just use the normal rules for the type.
-  auto value = EmitScalarExpr(E);
-  return {value, getPointerAuthInfoForType(CGM, E->getType())};
+  auto *Value = EmitScalarExpr(E);
+  return {Value, getPointerAuthInfoForType(CGM, E->getType())};
 }
 
 llvm::Value *
-CodeGenFunction::EmitPointerAuthQualify(PointerAuthQualifier destQualifier,
+CodeGenFunction::EmitPointerAuthQualify(PointerAuthQualifier DestQualifier,
                                         const Expr *E,
-                                        Address destStorageAddress) {
-  assert(destQualifier);
+                                        Address DestStorageAddress) {
+  assert(DestQualifier);
 
-  auto src = EmitOrigPointerRValue(E);
-  auto value = src.first;
-  auto curAuthInfo = src.second;
+  auto Src = EmitOrigPointerRValue(E);
+  auto *Value = Src.first;
+  auto CurAuthInfo = Src.second;
 
-  auto destAuthInfo = EmitPointerAuthInfo(destQualifier, destStorageAddress);
-  return emitPointerAuthResign(value, E->getType(), curAuthInfo, destAuthInfo,
+  auto DestAuthInfo = EmitPointerAuthInfo(DestQualifier, DestStorageAddress);
+  return emitPointerAuthResign(Value, E->getType(), CurAuthInfo, DestAuthInfo,
                                isPointerKnownNonNull(E));
 }
 
 llvm::Value *CodeGenFunction::EmitPointerAuthQualify(
-    PointerAuthQualifier destQualifier, llvm::Value *value,
-    QualType pointerType, Address destStorageAddress, bool isKnownNonNull) {
-  assert(destQualifier);
+    PointerAuthQualifier DestQualifier, llvm::Value *Value,
+    QualType PointerType, Address DestStorageAddress, bool IsKnownNonNull) {
+  assert(DestQualifier);
 
-  auto curAuthInfo = getPointerAuthInfoForType(CGM, pointerType);
-  auto destAuthInfo = EmitPointerAuthInfo(destQualifier, destStorageAddress);
-  return emitPointerAuthResign(value, pointerType, curAuthInfo, destAuthInfo,
-                               isKnownNonNull);
+  auto CurAuthInfo = getPointerAuthInfoForType(CGM, PointerType);
+  auto DestAuthInfo = EmitPointerAuthInfo(DestQualifier, DestStorageAddress);
+  return emitPointerAuthResign(Value, PointerType, CurAuthInfo, DestAuthInfo,
+                               IsKnownNonNull);
 }
 
 llvm::Value *CodeGenFunction::EmitPointerAuthUnqualify(
-    PointerAuthQualifier curQualifier, llvm::Value *value, QualType pointerType,
-    Address curStorageAddress, bool isKnownNonNull) {
-  assert(curQualifier);
-
-  auto curAuthInfo = EmitPointerAuthInfo(curQualifier, curStorageAddress);
-  auto destAuthInfo = getPointerAuthInfoForType(CGM, pointerType);
-  return emitPointerAuthResign(value, pointerType, curAuthInfo, destAuthInfo,
-                               isKnownNonNull);
+    PointerAuthQualifier CurQualifier, llvm::Value *Value, QualType PointerType,
+    Address CurStorageAddress, bool IsKnownNonNull) {
+  assert(CurQualifier);
+
+  auto CurAuthInfo = EmitPointerAuthInfo(CurQualifier, CurStorageAddress);
+  auto DestAuthInfo = getPointerAuthInfoForType(CGM, PointerType);
+  return emitPointerAuthResign(Value, PointerType, CurAuthInfo, DestAuthInfo,
+                               IsKnownNonNull);
 }
 
 static bool isZeroConstant(const llvm::Value *Value) {
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
