[Draft] Summary Based Analysis Prototype

clang/include/clang/Driver/Options.td

@@ -5941,6 +5941,22 @@ 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<"ReadSummaryDir">>;
+def emit_summaries_EQ : Joined<["-", "--"], "emit-summaries=">, Flags<[NoXarchOption]>,
+  Visibility<[ClangOption]>,
+  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 summary_format_EQ : Joined<["-", "--"], "summary-format=">, Flags<[NoXarchOption]>,
+  Visibility<[ClangOption, CC1Option]>,
+  HelpText<"The format of the emitted summaries. Can be set to 'json' (default), 'yaml', or 'binary'">;
 def save_stats_EQ : Joined<["-", "--"], "save-stats=">, Flags<[NoXarchOption]>,
   HelpText<"Save llvm statistics.">;
 def save_stats : Flag<["-", "--"], "save-stats">, Flags<[NoXarchOption]>,
@@ -8148,6 +8164,9 @@ defm emit_llvm_uselists : BoolOption<"", "emit-llvm-uselists",
   NegFlag<SetFalse, [], [ClangOption], "Don't preserve">,
   BothFlags<[], [ClangOption], " order of LLVM use-lists when serializing">>;
 
+def emit_summary_dir : Joined<["-"], "emit-summary-dir=">,
+  HelpText<"Directory to write summaries about function definitions to">,
+  MarshallingInfoString<FrontendOpts<"EmitSummaryDir">>;
 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,18 @@ class CompilerInstance : public ModuleLoader {
   /// The code completion consumer.
   std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;
 
+  /// The summary serializer.
+  std::unique_ptr<SummarySerializer> TheSummarySerializer;
+
+  /// 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 +626,34 @@ 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() { return SummaryCtx.get(); }
+
+  void createSummaryContext() { SummaryCtx.reset(new SummaryContext()); }
+
+  bool hasSummaryConsumer() const { return (bool)TheSummaryConsumer; }
+
+  SummaryConsumer *getSummaryConsumer() const {
+    return TheSummaryConsumer.get();
+  }
+
+  void createSummaryConsumer(FrontendInputFile Input);
+
+  bool hasSummarySerializer() const { return (bool)TheSummarySerializer; }
+
+  SummarySerializer &getSummarySerializer() const {
+    assert(TheSummarySerializer &&
+           "Compiler instance has no code summary serializer!");
+    return *TheSummarySerializer;
+  }
+
+  void createSummarySerializer();
+
   /// @}
   /// @name Frontend timer
   /// @{

clang/include/clang/Frontend/FrontendOptions.h

@@ -534,6 +534,15 @@ class FrontendOptions {
   /// minimization hints.
   std::string DumpMinimizationHintsPath;
 
+  /// The directory used to write summary files to.
+  std::string EmitSummaryDir;
+
+  /// The directory used to load summary files from.
+  std::string ReadSummaryDir;
+
+  /// The format of the summary files.
+  std::string SummaryFormat;
+
 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 *TheSummaryConsumer;
 
   /// 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,52 @@
+#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, NO_WRITE_PTR_PARAMETER };
+
+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,36 @@
+#ifndef LLVM_CLANG_SUMMARY_SUMMARYCONSUMER_H
+#define LLVM_CLANG_SUMMARY_SUMMARYCONSUMER_H
+
+#include "llvm/Support/raw_ostream.h"
+namespace clang {
+class FunctionSummary;
+class SummaryContext;
+class SummarySerializer;
+
+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 SerializingSummaryConsumer : public SummaryConsumer {
+  llvm::raw_ostream &OS;
+  SummarySerializer *Serializer;
+
+public:
+  SerializingSummaryConsumer(SummarySerializer &Serializer,
+                             llvm::raw_ostream &OS);
+
+  void ProcessEndOfSourceFile() override;
+};
+
+} // namespace clang
+
+#endif // LLVM_CLANG_SUMMARY_SUMMARYCONSUMER_H

clang/include/clang/Summary/SummaryContext.h

@@ -0,0 +1,75 @@
+#ifndef LLVM_CLANG_SUMMARY_SUMMARYCONTEXT_H
+#define LLVM_CLANG_SUMMARY_SUMMARYCONTEXT_H
+
+#include "clang/Summary/SummaryAttribute.h"
+#include "clang/Summary/SummaryConsumer.h"
+#include "llvm/Support/YAMLTraits.h"
+#include <set>
+
+namespace clang {
+class FunctionSummary {
+  size_t ID;
+  std::set<const SummaryAttr *> Attrs;
+  std::set<size_t> Calls;
+  bool CallsOpaque;
+
+public:
+  FunctionSummary(size_t ID, std::set<const SummaryAttr *> Attrs,
+                  std::set<size_t> Calls, bool CallsOpaque);
+
+  size_t getID() const { return ID; }
+  const std::set<const SummaryAttr *> &getAttributes() const { return Attrs; }
+  const std::set<size_t> &getCalls() const { return Calls; }
+  bool callsOpaqueObject() const { return CallsOpaque; }
+
+  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<std::string, size_t> IdentifierToID;
+  std::vector<StringRef> Identifiers;
+
+  std::map<size_t, const FunctionSummary *> IDToSummary;
+  std::vector<std::unique_ptr<FunctionSummary>> FunctionSummaries;
+
+  std::map<SummaryAttrKind, const SummaryAttr *> KindToAttribute;
+  std::vector<std::unique_ptr<SummaryAttr>> Attributes;
+
+  template <typename T> void RegisterAttr();
+
+public:
+  SummaryContext();
+
+  size_t GetOrInsertStoredIdentifierIdx(StringRef ID);
+  std::optional<size_t> GetStoredIdentifierIdx(StringRef ID) const;
+
+  void CreateSummary(size_t ID, std::set<const SummaryAttr *> Attrs,
+                     std::set<size_t> Calls, bool CallsOpaque);
+  bool ReduceFunctionSummary(FunctionSummary &FunctionSummary);
+
+  const std::vector<std::unique_ptr<FunctionSummary>> &GetSummaries() const {
+    return FunctionSummaries;
+  };
+  const std::vector<std::unique_ptr<SummaryAttr>> &GetAttributes() const {
+    return Attributes;
+  };
+  const std::vector<StringRef> &GetIdentifiers() const { return Identifiers; };
+
+  const FunctionSummary *GetSummary(const FunctionDecl *FD) const;
+  void SummarizeFunctionBody(const FunctionDecl *FD);
+  void ReduceSummaries();
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_SUMMARY_SUMMARYCONTEXTH