SSAFAnalysesCommon.cpp

Go to the documentation of this file.

//===- SSAFAnalysesCommon.cpp ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "SSAFAnalysesCommon.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DynamicRecursiveASTVisitor.h"
#include "clang/AST/ExprCXX.h"
#include "clang/Frontend/SSAFOptions.h"
#include "llvm/ADT/SetVector.h"
 
using namespace clang;
using namespace ssaf;
 
std::string ssaf::describeJSONValue(const llvm::json::Value &V) {
  return llvm::formatv("{0:2}", V).str();
}
 
std::string ssaf::describeJSONValue(const llvm::json::Array &A) {
  return llvm::formatv("array of size {0}", A.size()).str();
}
 
std::string ssaf::describeJSONValue(const llvm::json::Object &O) {
  return llvm::formatv("an object of {0} key(s)", O.size()).str();
}
 
namespace {
// Traverses the AST and finds contributors.
class ContributorFinder : public DynamicRecursiveASTVisitor {
public:
  llvm::SetVector<const NamedDecl *> Contributors;
  const SSAFOptions &Opts;
 
  ContributorFinder(const SSAFOptions &Opts) : Opts(Opts) {
    ShouldVisitTemplateInstantiations = true;
    ShouldVisitImplicitCode = false;
  }
 
  bool VisitFunctionDecl(FunctionDecl *D) override {
    Contributors.insert(D);
    return true;
  }
 
  bool VisitRecordDecl(RecordDecl *D) override {
    Contributors.insert(D);
    return true;
  }
 
  bool VisitVarDecl(VarDecl *D) override {
    DeclContext *DC = D->getDeclContext();
 
    // Collects Decl for global variables or static data members:
    if (DC->isFileContext() || D->isStaticDataMember()) {
      Contributors.insert(D);
      return true;
    }
 
    // Optionally include block-scope (function-local) variables. Parameters
    // are intentionally skipped: they are exposed via their parent function's
    // USR + a parameter-index suffix in getEntityName, so registering them as
    // independent contributors would be redundant.
    //
    // FIXME: clang::index::generateUSRForDecl can produce non-unique or empty
    // USRs for some local declaration shapes (e.g., locals of certain template
    // instantiations). The current addEntity path returns std::nullopt when
    // that happens and downstream extractors skip gracefully, so this is
    // tolerated for now.
    if (Opts.IncludeLocalEntities && !D->isImplicit() && !isa<ParmVarDecl>(D) &&
        DC->isFunctionOrMethod())
      Contributors.insert(D);
    return true;
  }
 
  bool VisitLambdaExpr(LambdaExpr *L) override {
    // TraverseLambdaExpr directly visits the body stmt, skipping the
    // CXXMethodDecl, which is a contributor that needs to be collected.
    VisitFunctionDecl(L->getCallOperator());
    return true;
  }
};
 
/// An AST visitor that skips the root node's strict-descendants that are
/// callable Decls and record Decls, because those are separate contributors.
///
/// Clients need to implement their own "MatchAction", which is a function that
/// takes a `DynTypedNode`, decides if the node matches and performs any further
/// callback actions.
/// ContributorFactFinder takes a reference to a "MatchAction". It does not own
/// the "MatchAction", which is usually stateful and may own containers.
class ContributorFactFinder : public DynamicRecursiveASTVisitor {
  llvm::function_ref<void(const DynTypedNode &)> MatchActionRef;
  const NamedDecl *RootDecl = nullptr;
 
  template <typename NodeTy> void match(const NodeTy &Node) {
    MatchActionRef(DynTypedNode::create(Node));
  }
 
public:
  ContributorFactFinder(
      llvm::function_ref<void(const DynTypedNode &)> MatchActionRef)
      : MatchActionRef(MatchActionRef) {
    ShouldVisitTemplateInstantiations = true;
    ShouldVisitImplicitCode = false;
  }
 
  // The entry point:
  void findMatches(const NamedDecl *Contributor) {
    RootDecl = Contributor;
    TraverseDecl(const_cast<NamedDecl *>(Contributor));
  }
 
  bool TraverseDecl(Decl *Node) override {
    if (!Node)
      return true;
    // To skip callables:
    if (Node != RootDecl &&
        isa<FunctionDecl, BlockDecl, ObjCMethodDecl, RecordDecl>(Node))
      return true;
    match(*Node);
    return DynamicRecursiveASTVisitor::TraverseDecl(Node);
  }
 
  bool TraverseStmt(Stmt *Node) override {
    if (!Node)
      return true;
    match(*Node);
    return DynamicRecursiveASTVisitor::TraverseStmt(Node);
  }
 
  bool TraverseLambdaExpr(LambdaExpr *L) override {
    // TODO: lambda captures of pointer variables (by copy or by reference)
    // are currently not tracked. Each capture initializes an implicit closure
    // field from the captured variable, which constitutes a pointer assignment
    // edge that should be recorded here.
    return true; // Skip lambda as it is a callable.
  }
};
} // namespace
 
void ssaf::findContributors(
    ASTContext &Ctx, const SSAFOptions &Options,
    llvm::DenseMap<const NamedDecl *, std::vector<const NamedDecl *>>
        &Contributors) {
  ContributorFinder Finder{Options};
  Finder.TraverseAST(Ctx);
  for (const NamedDecl *C : Finder.Contributors)
    Contributors[cast<NamedDecl>(C->getCanonicalDecl())].push_back(C);
}
 
void ssaf::findMatchesIn(
    const NamedDecl *Contributor,
    llvm::function_ref<void(const DynTypedNode &)> MatchActionRef) {
  ContributorFactFinder{MatchActionRef}.findMatches(Contributor);
}
 
llvm::Error clang::ssaf::makeEntityNameErr(clang::ASTContext &Ctx,
                                           const clang::NamedDecl *D) {
  return makeErrAtNode(Ctx, D, "failed to create entity name for %s",
                       D->getNameAsString().data());
}