[CHERI-CSA] clang-format

Author: resistor

clang/include/clang/StaticAnalyzer/Checkers/Checkers.td

@@ -1675,8 +1675,8 @@ def UnixAPIPortabilityChecker : Checker<"UnixAPI">,
   Documentation<NotDocumented>;
 
 def PointerAlignmentChecker : Checker<"PointerAlignment">,
-  HelpText<"Check underaligned pointers.">,
-  Documentation<NotDocumented>;
+                              HelpText<"Check underaligned pointers.">,
+                              Documentation<NotDocumented>;
 
 } // end optin.portability
 
@@ -1794,62 +1794,59 @@ def UncheckedLocalVarsChecker : Checker<"UncheckedLocalVarsChecker">,
 
 let ParentPackage = CHERI in {
 
-def CheriAPIModelling : Checker<"CheriAPIModelling">,
-  HelpText<"Model CheriAPI">,
-  Documentation<NotDocumented>;
-
-def ProvenanceSourceChecker : Checker<"ProvenanceSource">,
-  HelpText<"Check expressions with ambiguous provenance source.">,
-  CheckerOptions<[
-    CmdLineOption<Boolean,
-                  "ShowFixIts",
-                  "Enable fix-it hints for this checker",
-                  "false",
-                  InAlpha>,
-    CmdLineOption<Boolean,
-                  "ReportForAmbiguousProvenance",
-                  "Report for binary operations with ambiguous provenance "
-                  "for which the default capability derivation from LHS is fine. "
-                  "Disabled if [-Wcheri-provenance] is disabled.",
-                  "true",
-                  Released>
-  ]>,
-  Documentation<NotDocumented>;
-
-def CapabilityCopyChecker : Checker<"CapabilityCopy">,
-  HelpText<"Check tag-stripping memory copy.">,
-  CheckerOptions<[
-    CmdLineOption<Boolean,
-                  "ReportForCharPtr",
-                  "Report tag-stripping copy for char* function parameters. "
-                  "Suppression of warnings for C-strings is used to reduce "
-                  "the number of false alarms, but it's not very reliable.",
-                  "false",
-                  Released>
-  ]>,
-  Documentation<NotDocumented>;
-
-def PointerSizeAssumptionsChecker : Checker<"PointerSizeAssumptions">,
-  HelpText<"Detect hardcoded expectations on pointer sizes">,
-  Documentation<NotDocumented>;
-
-def SubObjectRepresentabilityChecker : Checker<"SubObjectRepresentability">,
-  HelpText<"Check for record fields with unrepresentable subobject bounds">,
-  Documentation<NotDocumented>;
+  def CheriAPIModelling : Checker<"CheriAPIModelling">,
+                          HelpText<"Model CheriAPI">,
+                          Documentation<NotDocumented>;
+
+  def ProvenanceSourceChecker
+      : Checker<"ProvenanceSource">,
+        HelpText<"Check expressions with ambiguous provenance source.">,
+        CheckerOptions<
+            [CmdLineOption<Boolean, "ShowFixIts",
+                           "Enable fix-it hints for this checker", "false",
+                           InAlpha>,
+             CmdLineOption<
+                 Boolean, "ReportForAmbiguousProvenance",
+                 "Report for binary operations with ambiguous provenance "
+                 "for which the default capability derivation from LHS is "
+                 "fine. "
+                 "Disabled if [-Wcheri-provenance] is disabled.",
+                 "true", Released>]>,
+        Documentation<NotDocumented>;
+
+  def CapabilityCopyChecker
+      : Checker<"CapabilityCopy">,
+        HelpText<"Check tag-stripping memory copy.">,
+        CheckerOptions<[CmdLineOption<
+            Boolean, "ReportForCharPtr",
+            "Report tag-stripping copy for char* function parameters. "
+            "Suppression of warnings for C-strings is used to reduce "
+            "the number of false alarms, but it's not very reliable.",
+            "false", Released>]>,
+        Documentation<NotDocumented>;
+
+  def PointerSizeAssumptionsChecker
+      : Checker<"PointerSizeAssumptions">,
+        HelpText<"Detect hardcoded expectations on pointer sizes">,
+        Documentation<NotDocumented>;
+
+  def SubObjectRepresentabilityChecker
+      : Checker<"SubObjectRepresentability">,
+        HelpText<
+            "Check for record fields with unrepresentable subobject bounds">,
+        Documentation<NotDocumented>;
 
 } // end cheri
 
 let ParentPackage = CHERIAlpha in {
 
-def AllocationChecker : Checker<"Allocation">,
-  HelpText<"Suggest narrowing bounds for escaping suballocation capabilities">,
-  CheckerOptions<[
-    CmdLineOption<Boolean,
-                  "ReportForUnknownAllocations",
-                  "Report for pointers with untracked origin",
-                  "true",
-                  Released>
-  ]>,
-  Documentation<NotDocumented>;
+  def AllocationChecker
+      : Checker<"Allocation">,
+        HelpText<
+            "Suggest narrowing bounds for escaping suballocation capabilities">,
+        CheckerOptions<[CmdLineOption<
+            Boolean, "ReportForUnknownAllocations",
+            "Report for pointers with untracked origin", "true", Released>]>,
+        Documentation<NotDocumented>;
 
 } // end alpha.cheri

clang/lib/Driver/ToolChains/Clang.cpp

@@ -28,7 +28,6 @@
 #include "clang/Basic/CLWarnings.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/CodeGenOptions.h"
-#include <clang/Basic/DiagnosticSema.h>
 #include "clang/Basic/HeaderInclude.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MakeSupport.h"
@@ -67,6 +66,7 @@
 #include "llvm/TargetParser/RISCVISAInfo.h"
 #include "llvm/TargetParser/RISCVTargetParser.h"
 #include <cctype>
+#include <clang/Basic/DiagnosticSema.h>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;

clang/lib/StaticAnalyzer/Checkers/CHERI/AllocationChecker.cpp

@@ -18,50 +18,40 @@
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
-#include <clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h>
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
-
+#include <clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h>
 
 using namespace clang;
 using namespace ento;
 using namespace cheri;
 
-
 struct EscapeInfo {
   PointerEscapeKind Kind;
   EscapeInfo(PointerEscapeKind K) : Kind(K) {};
-  bool operator==(const EscapeInfo &X) const {
-    return Kind == X.Kind;
-  }
-  void Profile(llvm::FoldingSetNodeID &ID) const {
-    ID.AddInteger(Kind);
-  }
+  bool operator==(const EscapeInfo &X) const { return Kind == X.Kind; }
+  void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger(Kind); }
 };
-using EscapePair = std::pair<const MemRegion*, EscapeInfo>;
+using EscapePair = std::pair<const MemRegion *, EscapeInfo>;
 
 namespace {
-class AllocationChecker : public Checker<check::PostStmt<CastExpr>,
-                                         check::PreCall,
-                                         check::PostCall,
-                                         check::Bind,
-                                         check::EndFunction,
-                                         check::DeadSymbols> {
+class AllocationChecker
+    : public Checker<check::PostStmt<CastExpr>, check::PreCall, check::PostCall,
+                     check::Bind, check::EndFunction, check::DeadSymbols> {
   BugType BT_Default{this, "Allocation partitioning", "CHERI portability"};
   BugType BT_UnknownReg{this, "Unknown allocation partitioning",
-                      "CHERI portability"};
+                        "CHERI portability"};
 
   const CallDescriptionSet IgnoreFnSet = {
       {CDM::SimpleFunc, {"free"}, 1},
   };
 
   const CallDescriptionSet CheriBoundsFnSet = {
-    {CDM::SimpleFunc, {"cheri_bounds_set"}, 2},
-    {CDM::SimpleFunc, {"cheri_bounds_set_exact"}, 2},
+      {CDM::SimpleFunc, {"cheri_bounds_set"}, 2},
+      {CDM::SimpleFunc, {"cheri_bounds_set_exact"}, 2},
   };
 
-
   class AllocPartitionBugVisitor : public BugReporterVisitor {
   public:
     AllocPartitionBugVisitor(const MemRegion *P, const MemRegion *A)
@@ -72,7 +62,6 @@ class AllocationChecker : public Checker<check::PostStmt<CastExpr>,
       ID.AddPointer(&X);
       ID.AddPointer(PrevAlloc);
       ID.AddPointer(SubAlloc);
-
     }
 
     PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
@@ -109,7 +98,6 @@ REGISTER_MAP_WITH_PROGRAMSTATE(ShiftMap, const MemRegion *, const MemRegion *)
 REGISTER_SET_WITH_PROGRAMSTATE(SuballocationSet, const MemRegion *)
 REGISTER_SET_WITH_PROGRAMSTATE(BoundedSet, const MemRegion *)
 
-
 namespace {
 std::pair<const MemRegion *, bool> getAllocationStart(const ASTContext &ASTCtx,
                                                       const MemRegion *R,
@@ -126,7 +114,7 @@ std::pair<const MemRegion *, bool> getAllocationStart(const ASTContext &ASTCtx,
   return std::make_pair(R, ZeroShift);
 }
 
-bool isAllocation(const MemRegion *R, const AllocationChecker* Chk) {
+bool isAllocation(const MemRegion *R, const AllocationChecker *Chk) {
   if (!Chk->ReportForUnknownAllocations) {
     const MemSpaceRegion *MemSpace = R->getMemorySpace();
     if (!isa<HeapSpaceRegion, GlobalsSpaceRegion, StackSpaceRegion>(MemSpace))
@@ -308,28 +296,35 @@ void AllocationChecker::checkPreCall(const CallEvent &Call,
 
   ProgramStateRef State = C.getState();
   ExplodedNode *N = nullptr;
-  bool Updated  = false;
+  bool Updated = false;
   for (unsigned Arg = 0; Arg < Call.getNumArgs(); ++Arg) {
     const Expr *ArgExpr = Call.getArgExpr(Arg);
     if (const MemRegion *MR = C.getSVal(ArgExpr).getAsRegion()) {
       if (State->contains<SuballocationSet>(MR)) {
         SmallString<256> Buf;
         llvm::raw_svector_ostream OS(Buf);
-        OS << "Pointer to suballocation passed to function as " << (Arg+1);
+        OS << "Pointer to suballocation passed to function as " << (Arg + 1);
         if (Arg + 1 < 11) {
-          switch (Arg+1) {
-          case 1: OS << "st"; break;
-          case 2: OS << "nd"; break;
-          case 3: OS << "rd"; break;
-          default: OS << "th"; break;
+          switch (Arg + 1) {
+          case 1:
+            OS << "st";
+            break;
+          case 2:
+            OS << "nd";
+            break;
+          case 3:
+            OS << "rd";
+            break;
+          default:
+            OS << "th";
+            break;
           }
         }
 
         OS << " argument";
         OS << " (consider narrowing the bounds for suballocation)";
-        N = emitAllocationPartitionWarning(
-            C, MR, ArgExpr->getSourceRange(),
-            OS.str());
+        N = emitAllocationPartitionWarning(C, MR, ArgExpr->getSourceRange(),
+                                           OS.str());
         if (N) {
           State = State->remove<SuballocationSet>(MR);
           Updated = true;

clang/lib/StaticAnalyzer/Checkers/CHERI/CHERIUtils.cpp

@@ -11,7 +11,6 @@
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 
-
 namespace clang {
 namespace ento {
 namespace cheri {

clang/lib/StaticAnalyzer/Checkers/CHERI/CHERIUtils.h

@@ -10,8 +10,8 @@
 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_CHERI_CHERIUTILS_H
 
 #include "clang/StaticAnalyzer/Core/Checker.h"
-#include <clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h>
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
+#include <clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h>
 
 namespace clang {
 namespace ento {
@@ -59,7 +59,7 @@ inline bool isLive(SymbolReaper &SymReaper, SymbolRef Sym) {
 
 template <typename M>
 ProgramStateRef cleanDead(ProgramStateRef State, SymbolReaper &SymReaper,
-                         bool &Removed) {
+                          bool &Removed) {
   const typename ProgramStateTrait<M>::data_type &Map = State->get<M>();
   for (const auto &E : Map) {
     const typename ProgramStateTrait<M>::key_type &K = getKey<M>(E);