[clang][dataflow] Add a `ControlFlowContext::build()` overload taking a `FunctionDecl`.

[mboehme]

Summary

This is the most common use case, so it makes sense to have a specific overload for it.

[xazax.hun]

clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h

39

I was wondering if there is a plan to make the framework work for non-functions, like global initializers.

[mboehme]

clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h

39

I believe there may be? I remember talking to someone who mentioned this -- I don't know, it might have been you?

This is, really, the only reason I can see for having an overload that takes a separate Stmt. It doesn't really make sense (I think) to pass a FunctionDecl to this overload and then pass some Stmt that isn't the complete function body. (I can't think of any good scenarios where the control flow wouldn't escape that Stmt, and I don't see any good use cases anyway.) So I've been assuming that this overload is there for global initializers. Confusingly, the comment says that D should be a function, but notably, D is a Decl, not a FunctionDecl -- so I think the comment is wrong here.

Anyway, I'll try and get some more insights into this, but until then, I'll certainly keep this overload in place.

[chapuni]

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

71

This was the only user of Body in -Asserts

[mboehme]

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

71

Thanks for pointing this out. Fixed in https://reviews.llvm.org/D151430.

clang/include/clang/Analysis/FlowSensitive/ControlFlowContext.h

 
 namespace clang {
 namespace dataflow {
 
 /// Holds CFG and other derived context that is needed to perform dataflow
 /// analysis.
 class ControlFlowContext {
 public:
+  /// Builds a ControlFlowContext from a `FunctionDecl`.
+  /// `Func.hasBody()` must be true, and `Func.isTemplated()` must be false.
+  static llvm::Expected<ControlFlowContext> build(const FunctionDecl &Func,
+                                                  ASTContext &C);
+
   /// Builds a ControlFlowContext from an AST node. `D` is the function in which
   /// `S` resides. `D.isTemplated()` must be false.
   static llvm::Expected<ControlFlowContext> build(const Decl &D, Stmt &S,
                                                   ASTContext &C);
 
   /// Builds a ControlFlowContext from an AST node. `D` is the function in which
   /// `S` resides. `D` must not be null and `D->isTemplated()` must be false.
   LLVM_DEPRECATED("Use the version that takes a const Decl & instead", "")
   static llvm::Expected<ControlFlowContext> build(const Decl *D, Stmt &S,

clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp

for (const CFGBlock *Succ : Block->succs())
       if (Succ)
         BlocksToVisit.push_back(Succ);
   }
 
   return BlockReachable;
 }
 
 llvm::Expected<ControlFlowContext>
+ControlFlowContext::build(const FunctionDecl &Func, ASTContext &C) {
+  if (!Func.hasBody())
+    return llvm::createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Cannot analyze function without a body");
+
+  return build(Func, *Func.getBody(), C);
+}
+
+llvm::Expected<ControlFlowContext>
 ControlFlowContext::build(const Decl &D, Stmt &S, ASTContext &C) {
   if (D.isTemplated())
     return llvm::createStringError(
         std::make_error_code(std::errc::invalid_argument),
         "Cannot analyze templated declarations");
 
   CFG::BuildOptions Options;
   Options.PruneTriviallyFalseEdges = true;

clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp

DataflowAnalysisContext::getControlFlowContext(const FunctionDecl *F) {
   // Canonicalize the key:
   F = F->getDefinition();
   if (F == nullptr)
     return nullptr;
   auto It = FunctionContexts.find(F);
   if (It != FunctionContexts.end())
     return &It->second;
 
-  if (Stmt *Body = F->getBody()) {
-    auto CFCtx = ControlFlowContext::build(*F, *Body, F->getASTContext());
+  if (F->hasBody()) {
+    auto CFCtx = ControlFlowContext::build(*F, F->getASTContext());
     // FIXME: Handle errors.
     assert(CFCtx);
     auto Result = FunctionContexts.insert({F, std::move(*CFCtx)});
     return &Result.first->second;
   }
 
   return nullptr;
 }

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

for (const ast_matchers::BoundNodes &BN :
                            Context)) {
     // Get the AST node of the target function.
     const FunctionDecl *Target = BN.getNodeAs<FunctionDecl>("target");
     if (Target == nullptr)
       return llvm::make_error<llvm::StringError>(
           llvm::errc::invalid_argument, "Could not find the target function.");
 
     // Build the control flow graph for the target function.
-    auto MaybeCFCtx =
-        ControlFlowContext::build(*Target, *Target->getBody(), Context);
+    auto MaybeCFCtx = ControlFlowContext::build(*Target, Context);
     if (!MaybeCFCtx) return MaybeCFCtx.takeError();
     auto &CFCtx = *MaybeCFCtx;
 
     // Initialize states for running dataflow analysis.
     DataflowAnalysisContext DACtx(std::make_unique<WatchedLiteralsSolver>(),
                                   {/*Opts=*/AI.BuiltinOptions});
     Environment InitEnv(DACtx, *Target);
     auto Analysis = AI.MakeAnalysis(Context, InitEnv);

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

runAnalysis(llvm::StringRef Code, AnalysisT (*MakeAnalysis)(ASTContext &)) {
   auto *Func = selectFirst<FunctionDecl>(
       "func", match(functionDecl(ast_matchers::hasName("target")).bind("func"),
                     AST->getASTContext()));
   assert(Func != nullptr);
 
   Stmt *Body = Func->getBody();
   assert(Body != nullptr);
 
-  auto CFCtx = llvm::cantFail(
-      ControlFlowContext::build(*Func, *Body, AST->getASTContext()));
+  auto CFCtx =
+      llvm::cantFail(ControlFlowContext::build(*Func, AST->getASTContext()));
 
   AnalysisT Analysis = MakeAnalysis(AST->getASTContext());
   DataflowAnalysisContext DACtx(std::make_unique<WatchedLiteralsSolver>());
   Environment Env(DACtx);
 
   return runDataflowAnalysis(CFCtx, Analysis, Env);
 }