Add Program Dependence Graph

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/Node.kt

@@ -35,6 +35,7 @@ import de.fraunhofer.aisec.cpg.graph.declarations.MethodDeclaration
 import de.fraunhofer.aisec.cpg.graph.declarations.RecordDeclaration
 import de.fraunhofer.aisec.cpg.graph.declarations.TranslationUnitDeclaration
 import de.fraunhofer.aisec.cpg.graph.declarations.TypedefDeclaration
+import de.fraunhofer.aisec.cpg.graph.edge.DependenceType
 import de.fraunhofer.aisec.cpg.graph.edge.Properties
 import de.fraunhofer.aisec.cpg.graph.edge.PropertyEdge
 import de.fraunhofer.aisec.cpg.graph.edge.PropertyEdge.Companion.unwrap
@@ -46,14 +47,11 @@ import de.fraunhofer.aisec.cpg.graph.scopes.Scope
 import de.fraunhofer.aisec.cpg.helpers.SubgraphWalker
 import de.fraunhofer.aisec.cpg.helpers.neo4j.LocationConverter
 import de.fraunhofer.aisec.cpg.helpers.neo4j.NameConverter
-import de.fraunhofer.aisec.cpg.passes.ControlDependenceGraphPass
-import de.fraunhofer.aisec.cpg.passes.ControlFlowSensitiveDFGPass
-import de.fraunhofer.aisec.cpg.passes.DFGPass
-import de.fraunhofer.aisec.cpg.passes.EvaluationOrderGraphPass
-import de.fraunhofer.aisec.cpg.passes.FilenameMapper
+import de.fraunhofer.aisec.cpg.passes.*
 import de.fraunhofer.aisec.cpg.processing.IVisitable
 import de.fraunhofer.aisec.cpg.sarif.PhysicalLocation
 import java.util.*
+import kotlin.collections.ArrayList
 import org.apache.commons.lang3.builder.ToStringBuilder
 import org.apache.commons.lang3.builder.ToStringStyle
 import org.neo4j.ogm.annotation.*
@@ -208,6 +206,24 @@ open class Node : IVisitable<Node>, Persistable, LanguageProvider, ScopeProvider
     @PopulatedByPass(DFGPass::class, ControlFlowSensitiveDFGPass::class)
     var nextDFG: MutableSet<Node> by PropertyEdgeSetDelegate(Node::nextDFGEdges, true)
 
+    /** Outgoing Program Dependence Edges. */
+    @PopulatedByPass(ProgramDependenceGraphPass::class)
+    @Relationship(value = "PDG", direction = Relationship.Direction.OUTGOING)
+    var nextPDGEdges: MutableList<PropertyEdge<Node>> = mutableListOf()
+        protected set
+
+    /** Virtual property for accessing the children of the Program Dependence Graph (PDG). */
+    var nextPDG by PropertyEdgeDelegate(Node::nextPDGEdges, true)
+
+    /** Incoming Program Dependence Edges. */
+    @PopulatedByPass(ProgramDependenceGraphPass::class)
+    @Relationship(value = "PDG", direction = Relationship.Direction.INCOMING)
+    var prevPDGEdges: MutableList<PropertyEdge<Node>> = mutableListOf()
+        protected set
+
+    /** Virtual property for accessing the parents of the Program Dependence Graph (PDG). */
+    var prevPDG by PropertyEdgeDelegate(Node::prevPDGEdges, false)
+
     var typedefs: MutableSet<TypedefDeclaration> = HashSet()
 
     /**
@@ -300,6 +316,20 @@ open class Node : IVisitable<Node>, Persistable, LanguageProvider, ScopeProvider
         prev.forEach { addPrevDFG(it, properties.toMutableMap()) }
     }
 
+    fun addAllPrevPDG(prev: Collection<Node>, dependenceType: DependenceType) {
+        addAllPrevPDGEdges(prev.map { PropertyEdge(it, this) }, dependenceType)
+    }
+
+    fun addAllPrevPDGEdges(prev: Collection<PropertyEdge<Node>>, dependenceType: DependenceType) {
+
+        prev.forEach {
+            val edge = PropertyEdge(it).apply { addProperty(Properties.DEPENDENCE, dependenceType) }
+            this.prevPDGEdges.add(edge)
+            val other = if (it.start != this) it.start else it.end
+            other.nextPDGEdges.add(edge)
+        }
+    }
+
     fun removePrevDFG(prev: Node?) {
         if (prev != null) {
             val thisRemove =

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/graph/edge/Properties.kt

@@ -38,12 +38,22 @@ package de.fraunhofer.aisec.cpg.graph.edge
  *
  * [UNREACHABLE]:(boolean) True if the edge flows into unreachable code i.e. a branch condition
  * which is always false.
+ *
+ * [DEPENDENCE]: ([DependenceType] Specifies the type of dependence the property edge might
+ * represent
  */
 enum class Properties {
     INDEX,
     BRANCH,
     NAME,
     INSTANTIATION,
     UNREACHABLE,
-    ACCESS
+    ACCESS,
+    DEPENDENCE
+}
+
+/** The types of dependencies that might be represented in the CPG */
+enum class DependenceType {
+    CONTROL,
+    DATA
 }

cpg-core/src/main/kotlin/de/fraunhofer/aisec/cpg/passes/ProgramDependenceGraphPass.kt

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2023, Fraunhofer AISEC. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *                    $$$$$$\  $$$$$$$\   $$$$$$\
+ *                   $$  __$$\ $$  __$$\ $$  __$$\
+ *                   $$ /  \__|$$ |  $$ |$$ /  \__|
+ *                   $$ |      $$$$$$$  |$$ |$$$$\
+ *                   $$ |      $$  ____/ $$ |\_$$ |
+ *                   $$ |  $$\ $$ |      $$ |  $$ |
+ *                   \$$$$$   |$$ |      \$$$$$   |
+ *                    \______/ \__|       \______/
+ *
+ */
+package de.fraunhofer.aisec.cpg.passes
+
+import de.fraunhofer.aisec.cpg.TranslationContext
+import de.fraunhofer.aisec.cpg.graph.*
+import de.fraunhofer.aisec.cpg.graph.declarations.TranslationUnitDeclaration
+import de.fraunhofer.aisec.cpg.graph.edge.DependenceType
+import de.fraunhofer.aisec.cpg.passes.order.DependsOn
+import de.fraunhofer.aisec.cpg.processing.IVisitor
+import de.fraunhofer.aisec.cpg.processing.strategy.Strategy
+
+/**
+ * This pass collects the dependence information of each node into a Program Dependence Graph (PDG)
+ * by traversing through the AST.
+ */
+@DependsOn(ControlDependenceGraphPass::class)
+@DependsOn(DFGPass::class)
+@DependsOn(ControlFlowSensitiveDFGPass::class, softDependency = true)
+class ProgramDependenceGraphPass(ctx: TranslationContext) : TranslationUnitPass(ctx) {
+    private val visitor =
+        object : IVisitor<Node>() {
+            /**
+             * Collects the data and control dependence edges of a node and adds them to the program
+             * dependence edges
+             */
+            override fun visit(t: Node) {
+                t.addAllPrevPDG(t.prevDFG, DependenceType.DATA)
+                t.addAllPrevPDGEdges(t.prevCDGEdges, DependenceType.CONTROL)
+            }
+        }
+
+    override fun accept(tu: TranslationUnitDeclaration) {
+        tu.statements.forEach(::handle)
+        tu.namespaces.forEach(::handle)
+        tu.declarations.forEach(::handle)
+    }
+
+    override fun cleanup() {
+        // Nothing to do
+    }
+
+    private fun handle(node: Node) {
+        node.accept(Strategy::AST_FORWARD, visitor)
+    }
+}

cpg-core/src/test/kotlin/de/fraunhofer/aisec/cpg/passes/ProgramDependenceGraphPassTest.kt

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2023, Fraunhofer AISEC. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *                    $$$$$$\  $$$$$$$\   $$$$$$\
+ *                   $$  __$$\ $$  __$$\ $$  __$$\
+ *                   $$ /  \__|$$ |  $$ |$$ /  \__|
+ *                   $$ |      $$$$$$$  |$$ |$$$$\
+ *                   $$ |      $$  ____/ $$ |\_$$ |
+ *                   $$ |  $$\ $$ |      $$ |  $$ |
+ *                   \$$$$$   |$$ |      \$$$$$   |
+ *                    \______/ \__|       \______/
+ *
+ */
+package de.fraunhofer.aisec.cpg.passes
+
+import de.fraunhofer.aisec.cpg.*
+import de.fraunhofer.aisec.cpg.frontends.TestLanguage
+import de.fraunhofer.aisec.cpg.frontends.TestLanguageFrontend
+import de.fraunhofer.aisec.cpg.graph.Node
+import de.fraunhofer.aisec.cpg.graph.builder.*
+import de.fraunhofer.aisec.cpg.graph.edge.DependenceType
+import de.fraunhofer.aisec.cpg.graph.edge.Properties
+import de.fraunhofer.aisec.cpg.graph.edge.PropertyEdge
+import de.fraunhofer.aisec.cpg.graph.functions
+import de.fraunhofer.aisec.cpg.graph.get
+import de.fraunhofer.aisec.cpg.processing.IVisitor
+import de.fraunhofer.aisec.cpg.processing.strategy.Strategy
+import java.util.*
+import java.util.stream.Stream
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+
+class ProgramDependenceGraphPassTest {
+
+    @ParameterizedTest(name = "test if pdg of {1} is equal to the union of cdg and dfg")
+    @MethodSource("provideTranslationResultForPDGTest")
+    fun `test if pdg is equal to union of cdg and dfg`(result: TranslationResult, name: String) {
+        assertNotNull(result)
+        val main = result.functions["main"]
+        assertNotNull(main)
+
+        main.accept(
+            Strategy::AST_FORWARD,
+            object : IVisitor<Node>() {
+                override fun visit(t: Node) {
+                    val expectedPrevEdges =
+                        t.prevCDGEdges.map {
+                            it.apply { addProperty(Properties.DEPENDENCE, DependenceType.CONTROL) }
+                        } +
+                            t.prevDFG.map {
+                                PropertyEdge(it, t).apply {
+                                    addProperty(Properties.DEPENDENCE, DependenceType.DATA)
+                                }
+                            }
+                    assertTrue(
+                        "prevPDGEdges did not contain all prevCDGEdges and edges to all prevDFG.\n" +
+                            "expectedPrevEdges: ${expectedPrevEdges.sortedBy { it.hashCode() }}\n" +
+                            "actualPrevEdges: ${t.prevPDGEdges.sortedBy { it.hashCode() }}"
+                    ) {
+                        compareListWithoutOrder(expectedPrevEdges, t.prevPDGEdges)
+                    }
+
+                    val expectedNextEdges =
+                        t.nextCDGEdges.map {
+                            it.apply { addProperty(Properties.DEPENDENCE, DependenceType.CONTROL) }
+                        } +
+                            t.nextDFG.map {
+                                PropertyEdge(t, it).apply {
+                                    addProperty(Properties.DEPENDENCE, DependenceType.DATA)
+                                }
+                            }
+                    assertTrue(
+                        "nextPDGEdges did not contain all nextCDGEdges and edges to all nextDFG." +
+                            "\nexpectedNextEdges: ${expectedNextEdges.sortedBy { it.hashCode() }}" +
+                            "\nactualNextEdges: ${t.nextPDGEdges.sortedBy { it.hashCode() }}"
+                    ) {
+                        compareListWithoutOrder(expectedNextEdges, t.nextPDGEdges)
+                    }
+                }
+            }
+        )
+    }
+
+    private fun <T> compareListWithoutOrder(expected: List<T>, actual: List<T>): Boolean {
+        val expectedWithDuplicatesGrouped = expected.groupingBy { it }.eachCount()
+        val actualWithDuplicatesGrouped = actual.groupingBy { it }.eachCount()
+
+        return expected.size == actual.size &&
+            expectedWithDuplicatesGrouped == actualWithDuplicatesGrouped
+    }
+
+    companion object {
+        fun testFrontend(config: TranslationConfiguration): TestLanguageFrontend {
+            val ctx = TranslationContext(config, ScopeManager(), TypeManager())
+            val language = config.languages.filterIsInstance<TestLanguage>().first()
+            return TestLanguageFrontend(language.namespaceDelimiter, language, ctx)
+        }
+
+        @JvmStatic
+        fun provideTranslationResultForPDGTest() =
+            Stream.of(
+                Arguments.of(getIfTest(), "if statement"),
+                Arguments.of(getWhileLoopTest(), "while loop")
+            )
+
+        private fun getIfTest() =
+            testFrontend(
+                    TranslationConfiguration.builder()
+                        .registerLanguage(TestLanguage("::"))
+                        .defaultPasses()
+                        .registerPass<ControlDependenceGraphPass>()
+                        .registerPass<ProgramDependenceGraphPass>()
+                        .build()
+                )
+                .build {
+                    translationResult {
+                        translationUnit("if.cpp") {
+                            // The main method
+                            function("main", t("int")) {
+                                body {
+                                    declare { variable("i", t("int")) { call("rand") } }
+                                    ifStmt {
+                                        condition { ref("i") lt literal(0, t("int")) }
+                                        thenStmt {
+                                            ref("i") assign (ref("i") * literal(-1, t("int")))
+                                        }
+                                    }
+                                    returnStmt { ref("i") }
+                                }
+                            }
+                        }
+                    }
+                }
+
+        private fun getWhileLoopTest() =
+            testFrontend(
+                    TranslationConfiguration.builder()
+                        .registerLanguage(TestLanguage("::"))
+                        .defaultPasses()
+                        .registerPass<ControlDependenceGraphPass>()
+                        .registerPass<ProgramDependenceGraphPass>()
+                        .build()
+                )
+                .build {
+                    translationResult {
+                        translationUnit("loop.cpp") {
+                            // The main method
+                            function("main", t("int")) {
+                                body {
+                                    declare { variable("i", t("int")) { call("rand") } }
+                                    whileStmt {
+                                        whileCondition { ref("i") gt literal(0, t("int")) }
+                                        loopBody {
+                                            call("printf") { literal("#", t("string")) }
+                                            ref("i").dec()
+                                        }
+                                    }
+                                    call("printf") { literal("\n", t("string")) }
+                                    returnStmt { literal(0, t("int")) }
+                                }
+                            }
+                        }
+                    }
+                }
+    }
+}