[DO NOT MERGE][SSAF][UnsafeBufferUsage] Implement AST visitor that respects the contribution model #188652

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed

ziqingluo-90 wants to merge 61 commits into main from users/ziqingluo/PR-172429193-2

clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h

-Original file line number
+Diff line change
@@ Expand Up @@
                      const SourceManager &SM);
     } // namespace internal
-    /// Find unsafe pointers in body/initializer of `D`, if `D` is one of the
-    /// followings:
-    ///   VarDecl
-    ///   FieldDecl
-    ///   FunctionDecl
-    ///   BlockDecl
-    ///   ObjCMethodDecl
-    std::set<const Expr *> findUnsafePointers(const Decl *D);
+    /// \return true iff `N` is an unsafe buffer usage and populates the unsafe
+    /// pointers in `UnsafePointers`
+    bool matchUnsafePointers(const DynTypedNode &N, ASTContext &Ctx,
+                             std::set<const Expr *> &UnsafePointers);
     } // end namespace clang
     #endif /* LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H */

clang/include/clang/ScalableStaticAnalysisFramework/Analyses/EntityPointerLevel.h

-Original file line number
+Diff line change
@@ -0,0 +1,134 @@
+    //===- EntityPointerLevel.h -------------------------------------*- C++ -*-===//
+    //
+    // 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
+    //
+    //===----------------------------------------------------------------------===//
+    #ifndef LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_H
+    #define LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_H
+    #include "clang/AST/Decl.h"
+    #include "clang/ScalableStaticAnalysisFramework/Core/Model/EntityId.h"
+    #include "clang/ScalableStaticAnalysisFramework/Core/Serialization/JSONFormat.h"
+    #include <set>
+    namespace clang::ssaf {
+    /// An EntityPointerLevel is associated with a level of the declared
+    /// pointer/array type of an entity.  In the fully-expanded spelling of the
+    /// declared type, a EntityPointerLevel is associated with a '*' (or a '[]`) in
+    /// that declaration.
+    ///
+    /// For example, for 'int *p[10];', there are two EntityPointerLevels. One
+    /// is associated with 'int *[10]' of 'p' and the other is associated with 'int
+    /// *' of 'p'.
+    ///
+    /// An EntityPointerLevel can be identified by an EntityId and an unsigned
+    /// integer indicating the pointer level: '(EntityId, PointerLevel)'.
+    /// An EntityPointerLevel 'P' is valid iff 'P.EntityId' has a pointer type with
+    /// at least 'P.PointerLevel' levels (This implies 'P.PointerLevel > 0').
+    ///
+    /// For the same example 'int *p[10];', the EntityPointerLevels below are valid:
+    /// - '(p, 2)' is associated with the 'int *' part of the declared type of 'p';
+    /// - '(p, 1)' is associated with the 'int *[10]' part of the declared type of
+    /// 'p'.
+    class EntityPointerLevel {
+      EntityId Entity;
+      unsigned PointerLevel;
+      friend class EntityPointerLevelTranslator;
+      friend llvm::Expected<EntityPointerLevel>
+      entityPointerLevelFromJSON(const llvm::json::Value &EPLData,
+                                 JSONFormat::EntityIdFromJSONFn EntityIdFromJSON);
+      // For unittests:
+      friend EntityPointerLevel buildEntityPointerLevel(EntityId, unsigned);
+      // EntityPointerLevel(EntityId Entity, unsigned PointerLevel)
+      //     : Entity(Entity), PointerLevel(PointerLevel) {}
+      EntityPointerLevel(std::pair<EntityId, unsigned> Pair)
+          : Entity(Pair.first), PointerLevel(Pair.second) {}
+    public:
+      EntityId getEntity() const { return Entity; }
+      unsigned getPointerLevel() const { return PointerLevel; }
+      bool operator==(const EntityPointerLevel &Other) const {
+        return std::tie(Entity, PointerLevel) ==
+               std::tie(Other.Entity, Other.PointerLevel);
+      }
+      bool operator!=(const EntityPointerLevel &Other) const {
+        return !(*this == Other);
+      }
+      bool operator<(const EntityPointerLevel &Other) const {
+        return std::tie(Entity, PointerLevel) <
+               std::tie(Other.Entity, Other.PointerLevel);
+      }
+      /// Compares `EntityPointerLevel`s; additionally, partially compares
+      /// `EntityPointerLevel` with `EntityId`.
+      struct Comparator {
+        using is_transparent = void;
+        bool operator()(const EntityPointerLevel &L,
+                        const EntityPointerLevel &R) const {
+          return L < R;
+        }
+        bool operator()(const EntityId &L, const EntityPointerLevel &R) const {
+          return L < R.getEntity();
+        }
+        bool operator()(const EntityPointerLevel &L, const EntityId &R) const {
+          return L.getEntity() < R;
+        }
+      };
+    };
+    using EntityPointerLevelSet =
+        std::set<EntityPointerLevel, EntityPointerLevel::Comparator>;
+    /// Translate a pointer/array type expression 'E' to a (set of)
+    /// EntityPointerLevel(s) associated with the declared type of the base address
+    /// of `E`. If the base address of `E` is not associated with an entity, the
+    /// translation result is an empty set.
+    ///
+    /// \param E the pointer expression to be translated
+    /// \param Ctx the AST context of `E`
+    /// \param AddEntity the callback provided by the caller to convert EntityNames
+    /// to EntityIds.
+    llvm::Expected<EntityPointerLevelSet>
+    translateEntityPointerLevel(const Expr *E, ASTContext &Ctx,
+                                std::function<EntityId(EntityName EN)> AddEntity);
+    /// Create an EntityPointerLevel (EPL) from a NamedDecl of a pointer/array type.
+    ///
+    /// \param E the pointer expression to be translated
+    /// \param Ctx the AST context of `E`
+    /// \param AddEntity the callback provided by the caller to convert EntityNames
+    /// to EntityIds.
+    /// \param IsFunRet true iff the created EPL is associated with the return type
+    /// of a function entity.
+    llvm::Expected<EntityPointerLevel>
+    createEntityPointerLevel(const NamedDecl *ND, ASTContext &Ctx,
+                             std::function<EntityId(EntityName EN)> AddEntity,
+                             bool IsFunRet = false);
+    /// Creates a new EntityPointerLevel (EPL) from `E` by incrementing `E`'s
+    /// pointer level.
+    /// \return the EPL that is associated with the pointee (or array element) type
+    /// of `E`'s associated pointer/array tyoe of the same entity.
+    EntityPointerLevel incrementPointerLevel(const EntityPointerLevel &E);
+    llvm::json::Value
+    entityPointerLevelToJSON(const EntityPointerLevel &EPL,
+                             JSONFormat::EntityIdToJSONFn EntityId2JSON);
+    llvm::Expected<EntityPointerLevel>
+    entityPointerLevelFromJSON(const llvm::json::Value &EPLData,
+                               JSONFormat::EntityIdFromJSONFn EntityIdFromJSON);
+    /// Proxy function creating EPLs for unit tests:
+    EntityPointerLevel buildEntityPointerLevel(EntityId, unsigned);
+    } // namespace clang::ssaf
+    #endif // LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_H

...de/clang/ScalableStaticAnalysisFramework/Analyses/EntityPointerLevel/EntityPointerLevel.h

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -12,17 +12,19 @@
  
    #include "clang/AST/Expr.h"

    #include "clang/ScalableStaticAnalysisFramework/Core/Model/EntityId.h"

    #include "clang/ScalableStaticAnalysisFramework/Core/Model/EntityName.h"

    #include "llvm/ADT/STLFunctionalExtras.h"

    #include <set>

    namespace clang::ssaf {

    /// An EntityPointerLevel represents a level of the declared pointer/array

    /// type of an entity.  In the fully-expanded spelling of the declared type, a

    /// EntityPointerLevel is associated with a '*' (or a '[]`) in that declaration.

    /// An EntityPointerLevel is associated with a level of the declared

    /// pointer/array type of an entity.  In the fully-expanded spelling of the

    /// declared type, a EntityPointerLevel is associated with a '*' (or a '[]`) in

    /// that declaration.

    ///

    /// For example, for 'int *p[10];', there are two EntityPointerLevels. One

    /// is associated with 'int *[10]' of 'p' and the other is associated with 'int

    /// *' of 'p'.

    /// For example, for 'int *p[10];', there are two EntityPointerLevels.

    /// One is associated with 'int *[10]' of 'p' and the other is associated with

    /// 'int *' of 'p'.

    ///

    /// An EntityPointerLevel can be identified by an EntityId and an unsigned

    /// integer indicating the pointer level: '(EntityId, PointerLevel)'.

    @@ -32,16 +34,17 @@ namespace clang::ssaf {
  
    /// For the same example 'int *p[10];', the EntityPointerLevels below are valid:

    /// - '(p, 2)' is associated with the 'int *' part of the declared type of 'p';

    /// - '(p, 1)' is associated with the 'int *[10]' part of the declared type of

    /// 'p'.

    ///   'p'.

    class EntityPointerLevel {

      EntityId Entity;

      unsigned PointerLevel;

      friend class EntityPointerLevelTranslator;

      // For unittests:

      friend EntityPointerLevel buildEntityPointerLevel(EntityId, unsigned);

      EntityPointerLevel(EntityId Entity, unsigned PointerLevel)

          : Entity(Entity), PointerLevel(PointerLevel) {}

      EntityPointerLevel(std::pair<EntityId, unsigned> Pair)

          : Entity(Pair.first), PointerLevel(Pair.second) {}

    public:

      EntityId getEntity() const { return Entity; }

    @@ -90,10 +93,31 @@ using EntityPointerLevelSet =
  
    /// \param Ctx the AST context of `E`

    /// \param AddEntity the callback provided by the caller to convert EntityNames

    /// to EntityIds.

    llvm::Expected<EntityPointerLevelSet>

    translateEntityPointerLevel(const Expr *E, ASTContext &Ctx,

                                std::function<EntityId(EntityName EN)> AddEntity);

    llvm::Expected<EntityPointerLevelSet> translateEntityPointerLevel(

        const Expr *E, ASTContext &Ctx,

        llvm::function_ref<EntityId(EntityName EN)> AddEntity);

    /// Creates a `EntityPointerLevel` from a pair of an EntityId and a pointer

    /// level:

    EntityPointerLevel buildEntityPointerLevel(EntityId, unsigned);

    /// Create an EntityPointerLevel (EPL) from a NamedDecl of a pointer/array type.

    ///

    /// \param ND the NamedDecl of a pointer/array type.

    /// \param AddEntity the callback provided by the caller to convert EntityNames

    /// to EntityIds.

    /// \param IsFunRet true iff the created EPL is associated with the return type

    /// of a function entity.

    llvm::Expected<EntityPointerLevel>

    creatEntityPointerLevel(const NamedDecl *ND,

                            llvm::function_ref<EntityId(EntityName EN)> AddEntity,

                            bool IsFunRet = false);

    /// Creates a new EntityPointerLevel (EPL) from `E` by incrementing `E`'s

    /// pointer level.

    /// \return the EPL that is associated with the pointee (or array element) type

    /// of `E`'s associated pointer/array tyoe of the same entity.

    EntityPointerLevel incrementPointerLevel(const EntityPointerLevel &E);

    } // namespace clang::ssaf

    #endif // LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_ENTITYPOINTERLEVEL_H

...ng/ScalableStaticAnalysisFramework/Analyses/EntityPointerLevel/EntityPointerLevelFormat.h

-Original file line number
+Diff line change
@@ -0,0 +1,25 @@
+    //===- EntityPointerLevelFormat.h -------------------------------*- C++-*-===//
+    //
+    // 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
+    //
+    //===----------------------------------------------------------------------===//
+    #ifndef LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_ENTITYPOINTERLEVELFORMAT_H
+    #define LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_ENTITYPOINTERLEVELFORMAT_H
+    #include "clang/ScalableStaticAnalysisFramework/Analyses/EntityPointerLevel/EntityPointerLevel.h"
+    #include "clang/ScalableStaticAnalysisFramework/Core/Serialization/JSONFormat.h"
+    namespace clang::ssaf {
+    llvm::json::Value
+    entityPointerLevelToJSON(const EntityPointerLevel &EPL,
+                             JSONFormat::EntityIdToJSONFn EntityId2JSON);
+    Expected<EntityPointerLevel>
+    entityPointerLevelFromJSON(const llvm::json::Value &EPLData,
+                               JSONFormat::EntityIdFromJSONFn EntityIdFromJSON);
+    } // namespace clang::ssaf
+    #endif // LLVM_CLANG_SCALABLESTATICANALYSISFRAMEWORK_ANALYSES_ENTITYPOINTERLEVEL_ENTITYPOINTERLEVELFORMAT_H

...lude/clang/ScalableStaticAnalysisFramework/Analyses/UnsafeBufferUsage/UnsafeBufferUsage.h

-Original file line number
+Diff line change
@@ Expand Up / @@ -12,14 +12,10 @@ @@
     #include "clang/ScalableStaticAnalysisFramework/Analyses/EntityPointerLevel/EntityPointerLevel.h"
     #include "clang/ScalableStaticAnalysisFramework/Core/Model/SummaryName.h"
     #include "clang/ScalableStaticAnalysisFramework/Core/TUSummary/EntitySummary.h"
-    #include "llvm/ADT/StringRef.h"
-    #include "llvm/ADT/iterator_range.h"
-    #include <set>
     namespace clang::ssaf {
-    /// An UnsafeBufferUsageEntitySummary is an immutable set of unsafe buffers, in
-    /// the form of EntityPointerLevel.
+    /// An UnsafeBufferUsageEntitySummary contains a set of EntityPointerLevels
+    /// extracted from unsafe buffer pointers contributed by an entity.
     class UnsafeBufferUsageEntitySummary final : public EntitySummary {
       const EntityPointerLevelSet UnsafeBuffers;
@@ Expand Down @@

...g/ScalableStaticAnalysisFramework/Analyses/UnsafeBufferUsage/UnsafeBufferUsageExtractor.h

This file was deleted.

clang/include/clang/ScalableStaticAnalysisFramework/SSAFBuiltinForceLinker.h

-Original file line number
+Diff line change
@@ Expand Up @@
     [[maybe_unused]] static int UnsafeBufferUsageSSAFJSONFormatAnchorDestination =
         UnsafeBufferUsageSSAFJSONFormatAnchorSource;
+    extern volatile int UnsafeBufferUsageTUSummaryExtractorAnchorSource;
+    [[maybe_unused]] static int
+        UnsafeBufferUsageTUSummaryExtractorAnchorDestination =
+            UnsafeBufferUsageTUSummaryExtractorAnchorSource;
     // This anchor is used to force the linker to link the CallGraphExtractor.
     extern volatile int CallGraphExtractorAnchorSource;
     [[maybe_unused]] static int CallGraphExtractorAnchorDestination =
@@ Expand Down @@

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[DO NOT MERGE][SSAF][UnsafeBufferUsage] Implement AST visitor that respects the contribution model #188652

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!