[PM/AA] Run clang-format over LibCallAliasAnalysis prior to making

substantial changes needed for the new pass manager's AA integration.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@245000 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/LibCallAliasAnalysis.h b/include/llvm/Analysis/LibCallAliasAnalysis.h
index 12b10a988eb0d3c92db2ac4243e9466b3d5ba4cc..36d9e063312faaf157c2ca105acddda3db96afe4 100644 (file)
--- a/include/llvm/Analysis/LibCallAliasAnalysis.h
+++ b/include/llvm/Analysis/LibCallAliasAnalysis.h
@@ -19,53 +19,55 @@
 #include "llvm/Pass.h"
 
 namespace llvm {
-  class LibCallInfo;
-  struct LibCallFunctionInfo;
-  
-  /// LibCallAliasAnalysis - Alias analysis driven from LibCallInfo.
-  struct LibCallAliasAnalysis : public FunctionPass, public AliasAnalysis {
-    static char ID; // Class identification
-    
-    LibCallInfo *LCI;
-    
-    explicit LibCallAliasAnalysis(LibCallInfo *LC = nullptr)
-        : FunctionPass(ID), LCI(LC) {
-      initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry());
-    }
-    explicit LibCallAliasAnalysis(char &ID, LibCallInfo *LC)
-        : FunctionPass(ID), LCI(LC) {
-      initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry());
-    }
-    ~LibCallAliasAnalysis() override;
 
-    ModRefInfo getModRefInfo(ImmutableCallSite CS,
-                             const MemoryLocation &Loc) override;
+class LibCallInfo;
+struct LibCallFunctionInfo;
 
-    ModRefInfo getModRefInfo(ImmutableCallSite CS1,
-                             ImmutableCallSite CS2) override {
-      // TODO: Could compare two direct calls against each other if we cared to.
-      return AliasAnalysis::getModRefInfo(CS1, CS2);
-    }
+/// LibCallAliasAnalysis - Alias analysis driven from LibCallInfo.
+struct LibCallAliasAnalysis : public FunctionPass, public AliasAnalysis {
+  static char ID; // Class identification
 
-    void getAnalysisUsage(AnalysisUsage &AU) const override;
+  LibCallInfo *LCI;
 
-    bool runOnFunction(Function &F) override;
+  explicit LibCallAliasAnalysis(LibCallInfo *LC = nullptr)
+      : FunctionPass(ID), LCI(LC) {
+    initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry());
+  }
+  explicit LibCallAliasAnalysis(char &ID, LibCallInfo *LC)
+      : FunctionPass(ID), LCI(LC) {
+    initializeLibCallAliasAnalysisPass(*PassRegistry::getPassRegistry());
+  }
+  ~LibCallAliasAnalysis() override;
 
-    /// getAdjustedAnalysisPointer - This method is used when a pass implements
-    /// an analysis interface through multiple inheritance.  If needed, it
-    /// should override this to adjust the this pointer as needed for the
-    /// specified pass info.
-    void *getAdjustedAnalysisPointer(const void *PI) override {
-      if (PI == &AliasAnalysis::ID)
-        return (AliasAnalysis*)this;
-      return this;
-    }
-    
-  private:
-    ModRefInfo AnalyzeLibCallDetails(const LibCallFunctionInfo *FI,
-                                     ImmutableCallSite CS,
-                                     const MemoryLocation &Loc);
-  };
-}  // End of llvm namespace
+  ModRefInfo getModRefInfo(ImmutableCallSite CS,
+                           const MemoryLocation &Loc) override;
+
+  ModRefInfo getModRefInfo(ImmutableCallSite CS1,
+                           ImmutableCallSite CS2) override {
+    // TODO: Could compare two direct calls against each other if we cared to.
+    return AliasAnalysis::getModRefInfo(CS1, CS2);
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+
+  bool runOnFunction(Function &F) override;
+
+  /// getAdjustedAnalysisPointer - This method is used when a pass implements
+  /// an analysis interface through multiple inheritance.  If needed, it
+  /// should override this to adjust the this pointer as needed for the
+  /// specified pass info.
+  void *getAdjustedAnalysisPointer(const void *PI) override {
+    if (PI == &AliasAnalysis::ID)
+      return (AliasAnalysis *)this;
+    return this;
+  }
+
+private:
+  ModRefInfo AnalyzeLibCallDetails(const LibCallFunctionInfo *FI,
+                                   ImmutableCallSite CS,
+                                   const MemoryLocation &Loc);
+};
+
+} // End of llvm namespace
 
 #endif

diff --git a/lib/Analysis/LibCallAliasAnalysis.cpp b/lib/Analysis/LibCallAliasAnalysis.cpp
index c9e2585bd6649013a83e74d6eb0444d925fd3eb8..8e839e8ce758899b21c7761d8235037276d05b2c 100644 (file)
--- a/lib/Analysis/LibCallAliasAnalysis.cpp
+++ b/lib/Analysis/LibCallAliasAnalysis.cpp
@@ -27,13 +27,11 @@ FunctionPass *llvm::createLibCallAliasAnalysisPass(LibCallInfo *LCI) {
   return new LibCallAliasAnalysis(LCI);
 }
 
-LibCallAliasAnalysis::~LibCallAliasAnalysis() {
-  delete LCI;
-}
+LibCallAliasAnalysis::~LibCallAliasAnalysis() { delete LCI; }
 
 void LibCallAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
   AliasAnalysis::getAnalysisUsage(AU);
-  AU.setPreservesAll();                         // Does not transform code
+  AU.setPreservesAll(); // Does not transform code
 }
 
 bool LibCallAliasAnalysis::runOnFunction(Function &F) {
@@ -61,52 +59,54 @@ LibCallAliasAnalysis::AnalyzeLibCallDetails(const LibCallFunctionInfo *FI,
   const LibCallFunctionInfo::LocationMRInfo *Details = FI->LocationDetails;
   if (Details == nullptr)
     return MRInfo;
-  
+
   // If the details array is of the 'DoesNot' kind, we only know something if
   // the pointer is a match for one of the locations in 'Details'.  If we find a
   // match, we can prove some interactions cannot happen.
-  // 
+  //
   if (FI->DetailsType == LibCallFunctionInfo::DoesNot) {
     // Find out if the pointer refers to a known location.
     for (unsigned i = 0; Details[i].LocationID != ~0U; ++i) {
       const LibCallLocationInfo &LocInfo =
-      LCI->getLocationInfo(Details[i].LocationID);
+          LCI->getLocationInfo(Details[i].LocationID);
       LibCallLocationInfo::LocResult Res = LocInfo.isLocation(CS, Loc);
-      if (Res != LibCallLocationInfo::Yes) continue;
-      
+      if (Res != LibCallLocationInfo::Yes)
+        continue;
+
       // If we find a match against a location that we 'do not' interact with,
       // learn this info into MRInfo.
       return ModRefInfo(MRInfo & ~Details[i].MRInfo);
     }
     return MRInfo;
   }
-  
+
   // If the details are of the 'DoesOnly' sort, we know something if the pointer
   // is a match for one of the locations in 'Details'.  Also, if we can prove
   // that the pointers is *not* one of the locations in 'Details', we know that
   // the call is MRI_NoModRef.
   assert(FI->DetailsType == LibCallFunctionInfo::DoesOnly);
-  
+
   // Find out if the pointer refers to a known location.
   bool NoneMatch = true;
   for (unsigned i = 0; Details[i].LocationID != ~0U; ++i) {
     const LibCallLocationInfo &LocInfo =
-    LCI->getLocationInfo(Details[i].LocationID);
+        LCI->getLocationInfo(Details[i].LocationID);
     LibCallLocationInfo::LocResult Res = LocInfo.isLocation(CS, Loc);
-    if (Res == LibCallLocationInfo::No) continue;
-    
+    if (Res == LibCallLocationInfo::No)
+      continue;
+
     // If we don't know if this pointer points to the location, then we have to
     // assume it might alias in some case.
     if (Res == LibCallLocationInfo::Unknown) {
       NoneMatch = false;
       continue;
     }
-    
+
     // If we know that this pointer definitely is pointing into the location,
     // merge in this information.
     return ModRefInfo(MRInfo & Details[i].MRInfo);
   }
-  
+
   // If we found that the pointer is guaranteed to not match any of the
   // locations in our 'DoesOnly' rule, then we know that the pointer must point
   // to some other location.  Since the libcall doesn't mod/ref any other
@@ -136,7 +136,7 @@ ModRefInfo LibCallAliasAnalysis::getModRefInfo(ImmutableCallSite CS,
       }
     }
   }
-  
+
   // The AliasAnalysis base class has some smarts, lets use them.
   return (ModRefInfo)(MRInfo | AliasAnalysis::getModRefInfo(CS, Loc));
 }