[Draft] Summary Based Analysis Prototype

clang/include/clang/Driver/Options.td

@@ -5941,6 +5941,19 @@ def save_temps : Flag<["-", "--"], "save-temps">, Flags<[NoXarchOption]>,
   Visibility<[ClangOption, FlangOption, FC1Option]>,
   Alias<save_temps_EQ>, AliasArgs<["cwd"]>,
   HelpText<"Alias for --save-temps=cwd">;
+def summaries_dir_EQ : Joined<["-", "--"], "summaries-dir=">, Flags<[NoXarchOption]>,
+  Visibility<[ClangOption, CC1Option]>,
+  HelpText<"Read summaries about different functions from this directory">,
+  MarshallingInfoString<FrontendOpts<"SummaryDirPath">>;
+def emit_summaries_EQ : Joined<["-", "--"], "emit-summaries=">, Flags<[NoXarchOption]>,
+  Visibility<[ClangOption, CC1Option]>,
+  HelpText<"Save summaries about the different functions. <arg> can be set to 'cwd' for "
+  "current working directory, or 'obj' which will save temporary files in the "
+  "same directory as the final output file">;
+def emit_summaries : Flag<["-", "--"], "emit-summaries">, Flags<[NoXarchOption]>,
+  Visibility<[ClangOption]>,
+  Alias<emit_summaries_EQ>, AliasArgs<["cwd"]>,
+  HelpText<"Alias for --emit-summaries=cwd">;
 def save_stats_EQ : Joined<["-", "--"], "save-stats=">, Flags<[NoXarchOption]>,
   HelpText<"Save llvm statistics.">;
 def save_stats : Flag<["-", "--"], "save-stats">, Flags<[NoXarchOption]>,
@@ -8148,6 +8161,10 @@ defm emit_llvm_uselists : BoolOption<"", "emit-llvm-uselists",
   NegFlag<SetFalse, [], [ClangOption], "Don't preserve">,
   BothFlags<[], [ClangOption], " order of LLVM use-lists when serializing">>;
 
+def summary_file : Joined<["-"], "summary-file=">,
+  HelpText<"Filename to write summaries about function definitions to">,
+  MarshallingInfoString<FrontendOpts<"SummaryFile">>;
+
 def print_stats : Flag<["-"], "print-stats">,
   HelpText<"Print performance metrics and statistics">,
   MarshallingInfoFlag<FrontendOpts<"ShowStats">>;

clang/include/clang/Frontend/CompilerInstance.h

@@ -19,6 +19,7 @@
 #include "clang/Lex/DependencyDirectivesScanner.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleLoader.h"
+#include "clang/Summary/SummaryContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
@@ -48,6 +49,8 @@ class ModuleFile;
 }
 
 class CodeCompleteConsumer;
+class SummaryContext;
+class SummaryConsumer;
 class DiagnosticsEngine;
 class DiagnosticConsumer;
 class FileManager;
@@ -121,6 +124,15 @@ class CompilerInstance : public ModuleLoader {
   /// The code completion consumer.
   std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;
 
+  /// The summary consumer.
+  std::unique_ptr<SummaryConsumer> TheSummaryConsumer;
+
+  /// The summary context.
+  std::unique_ptr<SummaryContext> SummaryCtx;
+
+  /// The summary output file.
+  std::unique_ptr<llvm::raw_fd_ostream> SummaryOS;
+
   /// The semantic analysis object.
   std::unique_ptr<Sema> TheSema;
 
@@ -611,6 +623,29 @@ class CompilerInstance : public ModuleLoader {
   /// the compiler instance takes ownership of \p Value.
   void setCodeCompletionConsumer(CodeCompleteConsumer *Value);
 
+  /// @}
+  /// @name Summary
+  /// @{
+
+  bool hasSummaryContext() { return (bool)SummaryCtx; }
+
+  SummaryContext &getSummaryContext() {
+    assert(SummaryCtx && "Compiler instance has no summary context!");
+    return *SummaryCtx;
+  }
+
+  void createSummaryContext() { SummaryCtx.reset(new SummaryContext()); }
+
+  bool hasSummaryConsumer() const { return (bool)TheSummaryConsumer; }
+
+  SummaryConsumer &getSummaryConsumer() const {
+    assert(TheSummaryConsumer &&
+           "Compiler instance has no code summary consumer!");
+    return *TheSummaryConsumer;
+  }
+
+  void createSummaryConsumer();
+
   /// @}
   /// @name Frontend timer
   /// @{
@@ -738,7 +773,8 @@ class CompilerInstance : public ModuleLoader {
 
   /// Create the Sema object to be used for parsing.
   void createSema(TranslationUnitKind TUKind,
-                  CodeCompleteConsumer *CompletionConsumer);
+                  CodeCompleteConsumer *CompletionConsumer,
+                  SummaryConsumer *SummaryConsumer = nullptr);
 
   /// Create the frontend timer and replace any existing one with it.
   void createFrontendTimer();

clang/include/clang/Frontend/FrontendOptions.h

@@ -534,6 +534,12 @@ class FrontendOptions {
   /// minimization hints.
   std::string DumpMinimizationHintsPath;
 
+  /// Filename to write summaries about function definitions to.
+  std::string SummaryFile;
+
+  /// The directory used to load summary files.
+  std::string SummaryDirPath;
+
 public:
   FrontendOptions()
       : DisableFree(false), RelocatablePCH(false), ShowHelp(false),

clang/include/clang/Sema/Sema.h

@@ -125,6 +125,8 @@ class CXXBasePath;
 class CXXBasePaths;
 class CXXFieldCollector;
 class CodeCompleteConsumer;
+class SummaryContext;
+class SummaryConsumer;
 enum class ComparisonCategoryType : unsigned char;
 class ConstraintSatisfaction;
 class DarwinSDKInfo;
@@ -883,7 +885,9 @@ class Sema final : public SemaBase {
 public:
   Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
        TranslationUnitKind TUKind = TU_Complete,
-       CodeCompleteConsumer *CompletionConsumer = nullptr);
+       CodeCompleteConsumer *CompletionConsumer = nullptr,
+       SummaryContext *SummaryCtx = nullptr,
+       SummaryConsumer *SummaryConsumer = nullptr);
   ~Sema();
 
   /// Perform initialization that occurs after the parser has been
@@ -1260,6 +1264,8 @@ class Sema final : public SemaBase {
   DiagnosticsEngine &Diags;
   SourceManager &SourceMgr;
   api_notes::APINotesManager APINotes;
+  SummaryContext *SummaryCtx;
+  SummaryConsumer *SummaryCnsmr;
 
   /// A RAII object to enter scope of a compound statement.
   class CompoundScopeRAII {

clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h

@@ -21,19 +21,20 @@
 #include "clang/Analysis/DomainSpecific/ObjCNoReturn.h"
 #include "clang/Analysis/ProgramPoint.h"
 #include "clang/Basic/LLVM.h"
-#include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/WorkList.h"
+#include "clang/Summary/SummaryContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include <cassert>
 #include <optional>
@@ -178,10 +179,13 @@ class ExprEngine {
   /// The flag, which specifies the mode of inlining for the engine.
   InliningModes HowToInline;
 
+  const SummaryContext *SummaryCtx;
+
 public:
   ExprEngine(cross_tu::CrossTranslationUnitContext &CTU, AnalysisManager &mgr,
-             SetOfConstDecls *VisitedCalleesIn,
-             FunctionSummariesTy *FS, InliningModes HowToInlineIn);
+             SetOfConstDecls *VisitedCalleesIn, FunctionSummariesTy *FS,
+             InliningModes HowToInlineIn,
+             const SummaryContext *SummaryCtx = nullptr);
 
   virtual ~ExprEngine() = default;
 
@@ -214,6 +218,8 @@ class ExprEngine {
     return &CTU;
   }
 
+  const SummaryContext *getSummaryCtx() { return SummaryCtx; }
+
   const NodeBuilderContext &getBuilderContext() {
     assert(currBldrCtx);
     return *currBldrCtx;

clang/include/clang/Summary/SummaryAttribute.h

@@ -0,0 +1,54 @@
+#ifndef LLVM_CLANG_SUMMARY_SUMMARYATTRIBUTE_H
+#define LLVM_CLANG_SUMMARY_SUMMARYATTRIBUTE_H
+
+#include "clang/AST/Decl.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+namespace clang {
+enum SummaryAttrKind {
+  NO_WRITE_GLOBAL,
+};
+
+class FunctionSummary;
+class SummaryContext;
+
+class SummaryAttr {
+  const SummaryAttrKind Kind;
+  const char *Spelling;
+
+protected:
+  SummaryAttr(SummaryAttrKind Kind, const char *Spelling)
+      : Kind(Kind), Spelling(Spelling) {};
+
+public:
+  virtual ~SummaryAttr() = default;
+
+  SummaryAttrKind getKind() const { return Kind; }
+  const char *getSpelling() const { return Spelling; }
+
+  virtual bool infer(const FunctionDecl *FD) const = 0;
+  virtual bool merge(const FunctionSummary &Caller,
+                     const FunctionSummary &Callee) const = 0;
+
+  virtual std::string serialize() const { return std::string(Spelling); };
+  virtual bool parse(std::string_view input) const {
+    return input == Spelling;
+  };
+};
+
+class NoWriteGlobalAttr : public SummaryAttr {
+  NoWriteGlobalAttr() : SummaryAttr(NO_WRITE_GLOBAL, "no_write_global") {}
+
+public:
+  bool infer(const FunctionDecl *FD) const override final;
+  bool merge(const FunctionSummary &Caller,
+             const FunctionSummary &Callee) const override final;
+
+  static bool classof(const SummaryAttr *A) {
+    return A->getKind() == NO_WRITE_GLOBAL;
+  }
+  friend class SummaryContext;
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SUMMARY_SUMMARYATTRIBUTEH

clang/include/clang/Summary/SummaryConsumer.h

@@ -0,0 +1,45 @@
+#ifndef LLVM_CLANG_SUMMARY_SUMMARYCONSUMER_H
+#define LLVM_CLANG_SUMMARY_SUMMARYCONSUMER_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/Support/JSON.h"
+namespace clang {
+class FunctionSummary;
+class SummaryContext;
+
+class SummaryConsumer {
+protected:
+  const SummaryContext *SummaryCtx;
+
+public:
+  SummaryConsumer(const SummaryContext &SummaryCtx) : SummaryCtx(&SummaryCtx) {}
+  virtual ~SummaryConsumer() = default;
+
+  virtual void ProcessStartOfSourceFile() {};
+  virtual void ProcessFunctionSummary(const FunctionSummary &) {};
+  virtual void ProcessEndOfSourceFile() {};
+};
+
+class PrintingSummaryConsumer : public SummaryConsumer {
+public:
+  PrintingSummaryConsumer(const SummaryContext &SummaryCtx, raw_ostream &OS)
+      : SummaryConsumer(SummaryCtx) {}
+};
+
+class JSONPrintingSummaryConsumer : public PrintingSummaryConsumer {
+  llvm::json::OStream JOS;
+
+public:
+  JSONPrintingSummaryConsumer(const SummaryContext &SummaryCtx, raw_ostream &OS)
+      : PrintingSummaryConsumer(SummaryCtx, OS), JOS(OS, 2) {}
+
+  void ProcessStartOfSourceFile() override { JOS.arrayBegin(); };
+  void ProcessFunctionSummary(const FunctionSummary &) override;
+  void ProcessEndOfSourceFile() override {
+    JOS.arrayEnd();
+    JOS.flush();
+  };
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SUMMARY_SUMMARYCONSUMER_H

clang/include/clang/Summary/SummaryContext.h

@@ -0,0 +1,60 @@
+#ifndef LLVM_CLANG_SUMMARY_SUMMARYCONTEXT_H
+#define LLVM_CLANG_SUMMARY_SUMMARYCONTEXT_H
+
+#include "clang/Summary/SummaryAttribute.h"
+#include "clang/Summary/SummaryConsumer.h"
+#include <set>
+
+namespace clang {
+class FunctionSummary {
+  SmallVector<char> ID;
+  std::set<const SummaryAttr *> Attrs;
+  std::set<SmallVector<char>> Calls;
+
+public:
+  FunctionSummary(SmallVector<char> ID, std::set<const SummaryAttr *> Attrs,
+                  std::set<SmallVector<char>> Calls);
+
+  SmallVector<char> getID() const { return ID; }
+  const std::set<const SummaryAttr *> &getAttributes() const { return Attrs; }
+  const std::set<SmallVector<char>> &getCalls() const { return Calls; }
+
+  template <typename T> bool hasAttribute() const {
+    for (auto &&attr : Attrs) {
+      if (llvm::isa<T>(attr))
+        return true;
+    }
+
+    return false;
+  }
+
+  void replaceAttributes(std::set<const SummaryAttr *> Attrs) {
+    this->Attrs = std::move(Attrs);
+  }
+};
+
+class SummaryContext {
+  std::map<SmallVector<char>, const FunctionSummary *> IDToSummary;
+  std::vector<std::unique_ptr<FunctionSummary>> FunctionSummaries;
+
+  std::map<SummaryAttrKind, const SummaryAttr *> KindToAttribute;
+  std::vector<std::unique_ptr<SummaryAttr>> Attributes;
+
+  void CreateSummary(SmallVector<char> ID, std::set<const SummaryAttr *> Attrs,
+                     std::set<SmallVector<char>> Calls);
+  bool ReduceFunctionSummary(FunctionSummary &FunctionSummary);
+
+  template <typename T> void registerAttr();
+
+public:
+  SummaryContext();
+
+  const FunctionSummary *GetSummary(const FunctionDecl *FD) const;
+  void SummarizeFunctionBody(const FunctionDecl *FD);
+
+  void ParseSummaryFromJSON(const llvm::json::Array &Summary);
+  void ReduceSummaries();
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SUMMARY_SUMMARYCONTEXTH

clang/lib/CMakeLists.txt

@@ -9,6 +9,7 @@ add_subdirectory(CrossTU)
 add_subdirectory(Sema)
 add_subdirectory(CodeGen)
 add_subdirectory(Analysis)
+add_subdirectory(Summary)
 add_subdirectory(Edit)
 add_subdirectory(ExtractAPI)
 add_subdirectory(Rewrite)