arkanalyzer 1.0.19 → 1.0.21

package/lib/core/dataflow/Edge.js

@@ -1,31 +1,31 @@
-"use strict";
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathEdge = exports.PathEdgePoint = void 0;
-class PathEdgePoint {
-    constructor(node, fact) {
-        this.node = node;
-        this.fact = fact;
-    }
-}
-exports.PathEdgePoint = PathEdgePoint;
-class PathEdge {
-    constructor(start, end) {
-        this.edgeStart = start;
-        this.edgeEnd = end;
-    }
-}
-exports.PathEdge = PathEdge;
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathEdge = exports.PathEdgePoint = void 0;
+class PathEdgePoint {
+    constructor(node, fact) {
+        this.node = node;
+        this.fact = fact;
+    }
+}
+exports.PathEdgePoint = PathEdgePoint;
+class PathEdge {
+    constructor(start, end) {
+        this.edgeStart = start;
+        this.edgeEnd = end;
+    }
+}
+exports.PathEdge = PathEdge;

package/lib/core/dataflow/Fact.d.ts

@@ -1,7 +1,7 @@
-import { Value } from '../base/Value';
-import { Stmt } from '../base/Stmt';
-export declare class Fact {
-    values: Set<Value>;
-    valueMap: Map<Value, Stmt>;
-}
+import { Value } from '../base/Value';
+import { Stmt } from '../base/Stmt';
+export declare class Fact {
+    values: Set<Value>;
+    valueMap: Map<Value, Stmt>;
+}
 //# sourceMappingURL=Fact.d.ts.map

package/lib/core/dataflow/Fact.js

@@ -1,24 +1,24 @@
-"use strict";
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Fact = void 0;
-class Fact {
-    constructor() {
-        this.values = new Set();
-        this.valueMap = new Map(); // 用最近的def代表value的值
-    }
-}
-exports.Fact = Fact;
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fact = void 0;
+class Fact {
+    constructor() {
+        this.values = new Set();
+        this.valueMap = new Map(); // 用最近的def代表value的值
+    }
+}
+exports.Fact = Fact;

package/lib/core/dataflow/GenericDataFlow.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Generic Data Flow Analysis Framework
+ *
+ * This module provides a generic framework for implementing data flow analyses,
+ * such as Reaching Definitions, Live Variables, and Available Expressions.
+ * The framework is designed to be flexible and extensible, allowing users to
+ * define custom flow graphs, transfer functions, and meet operations.
+ *
+ * Design Notes:
+ * - The framework is designed to be generic and reusable, allowing users to
+ *   implement custom data flow analyses by defining appropriate transfer functions
+ *   and meet operations.
+ * - The solver uses a worklist algorithm to efficiently compute the MFP solution.
+ * - The analysis can be configured as either forward or backward, depending on
+ *   the problem requirements.
+ *
+ */
+/**
+ * Represents a flow graph for data flow analysis.
+ * Provides access to nodes in post-order and reverse post-order, as well as
+ * methods to retrieve successors and predecessors of a given node.
+ *
+ * @template T - The type of nodes in the graph (e.g., node IDs or node objects).
+ */
+export interface FlowGraph<T> {
+    nodesInReversePostOrder?: T[];
+    nodesInPostOrder: T[];
+    pred(t: T): T[];
+    succ(t: T): T[];
+}
+/**
+ * DS (Data Set) is an interface that defines the basic operations for a data set.
+ * It requires the data set to be iterable, comparable, and countable.
+ */
+interface DS {
+    /**
+     * Returns an iterator that allows iterating over the elements of the data set.
+     * @returns An iterable iterator over the elements of the data set.
+     */
+    [Symbol.iterator](): IterableIterator<any>;
+    /**
+     * Checks whether the current data set is equal to another data set.
+     */
+    equals(d: DS): boolean;
+    /**
+     * Counts the number of elements in the data set.
+     */
+    count(): number;
+}
+/**
+ * Represents the transfer function used in data flow analysis.
+ * The transfer function computes the output value (out set) of a node
+ * based on its input value (in set) and the node's properties.
+ *
+ * @template Node - The type of nodes in the graph.
+ * @template V - The type of data flow values (e.g., sets, bit vectors).
+ */
+export interface TransferFunction<Node, V> {
+    /**
+     * Computes the output value for a node based on its input value.
+     *
+     * @param n - The node for which the output value is computed.
+     * @param x - The input value (in set) for the node.
+     * @returns The output value (out set) for the node.
+     */
+    apply(n: Node, x: V): V;
+}
+/**
+ * Represents a data flow problem, encapsulating all the necessary components
+ * for performing data flow analysis, such as the flow graph, transfer function,
+ * meet operation, and initialization configuration.
+ *
+ * @template Node - The type of nodes in the graph.
+ * @template V - The type of data flow values.
+ */
+export interface DataFlowProblem<Node, V> {
+    /**
+     * The flow graph for the data flow analysis.
+     */
+    flowGraph: FlowGraph<Node>;
+    /**
+     * The transfer function used to compute out sets from in sets.
+     */
+    transferFunction: TransferFunction<Node, V>;
+    /**
+     * The meet operation used to combine values from multiple paths (e.g., union or intersection).
+     */
+    meet: (a: V, b: V) => V;
+    /**
+     * The initialization configuration for in and out sets.
+     */
+    initIn: Map<Node, V>;
+    initOut: Map<Node, V>;
+    /**
+     * Indicates whether the analysis is forward (true) or backward (false).
+     */
+    forward: boolean;
+    /**
+     * The empty value used to initialize in and out sets (e.g., an empty set).
+     */
+    empty: V;
+}
+/**
+ * Represents the result of a data flow analysis.
+ * Contains the in and out sets for each node, as well as the corresponding data flow problem.
+ *
+ * @template Node - The type of nodes in the graph.
+ * @template V - The type of data flow values.
+ */
+export declare class Solution<Node, V> {
+    in: Map<Node, V>;
+    out: Map<Node, V>;
+    problem: DataFlowProblem<Node, V>;
+    constructor(i: Map<Node, V>, out: Map<Node, V>, problem: DataFlowProblem<Node, V>);
+}
+/**
+ * A solver for data flow analysis problems.
+ * Implements forward and backward data flow analysis using a worklist algorithm.
+ * The solver computes the Maximum Fixed Point (MFP) solution, which is a safe
+ * over-approximation of the ideal Meet-Over-All-Paths (MOP) solution.
+ */
+export declare class MFPDataFlowSolver {
+    /**
+     * Computes the MFP solution for a forward data flow analysis problem.
+     *
+     * @template Node - The type of nodes in the graph.
+     * @template V - The type of data flow values.
+     * @param problem - The data flow problem to solve.
+     * @returns The solution containing the in and out sets for all nodes.
+     */
+    calculateMopSolutionForwards<Node, V extends DS>(problem: DataFlowProblem<Node, V>): Solution<Node, V>;
+    /**
+     * Computes the MFP solution for a backward data flow analysis problem.
+     *
+     * @template Node - The type of nodes in the graph.
+     * @template V - The type of data flow values.
+     * @param problem - The data flow problem to solve.
+     * @returns The solution containing the in and out sets for all nodes.
+     */
+    calculateMopSolutionBackwards<Node, T extends DS>(problem: DataFlowProblem<Node, T>): Solution<Node, T>;
+}
+export {};
+//# sourceMappingURL=GenericDataFlow.d.ts.map

package/lib/core/dataflow/GenericDataFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenericDataFlow.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/GenericDataFlow.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAExB,uBAAuB,CAAC,EAAE,CAAC,EAAE,CAAC;IAE9B,gBAAgB,EAAE,CAAC,EAAE,CAAC;IAEtB,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;IAEhB,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;CACnB;AAED;;;GAGG;AACH,UAAU,EAAE;IACR;;;OAGG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAE3C;;OAEG;IACH,MAAM,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC;IAEvB;;OAEG;IACH,KAAK,IAAI,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB,CAAC,IAAI,EAAE,CAAC;IACrC;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe,CAAC,IAAI,EAAE,CAAC;IACpC;;OAEG;IACH,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IAC3B;;OAEG;IACH,gBAAgB,EAAE,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACxB;;OAEG;IACH,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACrB,OAAO,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACtB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,KAAK,EAAE,CAAC,CAAC;CACZ;AAED;;;;;;GAMG;AACH,qBAAa,QAAQ,CAAC,IAAI,EAAE,CAAC;IACzB,EAAE,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAClB,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBAEtB,CAAC,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC;CAKpF;AAED;;;;;GAKG;AACH,qBAAa,iBAAiB;IAC1B;;;;;;;OAOG;IACH,4BAA4B,CAAC,IAAI,EAAE,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IAkCtG;;;;;;;OAOG;IACH,6BAA6B,CAAC,IAAI,EAAE,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CA2B1G"}

package/lib/core/dataflow/GenericDataFlow.js

@@ -0,0 +1,109 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MFPDataFlowSolver = exports.Solution = void 0;
+/**
+ * Represents the result of a data flow analysis.
+ * Contains the in and out sets for each node, as well as the corresponding data flow problem.
+ *
+ * @template Node - The type of nodes in the graph.
+ * @template V - The type of data flow values.
+ */
+class Solution {
+    constructor(i, out, problem) {
+        this.in = i;
+        this.out = out;
+        this.problem = problem;
+    }
+}
+exports.Solution = Solution;
+/**
+ * A solver for data flow analysis problems.
+ * Implements forward and backward data flow analysis using a worklist algorithm.
+ * The solver computes the Maximum Fixed Point (MFP) solution, which is a safe
+ * over-approximation of the ideal Meet-Over-All-Paths (MOP) solution.
+ */
+class MFPDataFlowSolver {
+    /**
+     * Computes the MFP solution for a forward data flow analysis problem.
+     *
+     * @template Node - The type of nodes in the graph.
+     * @template V - The type of data flow values.
+     * @param problem - The data flow problem to solve.
+     * @returns The solution containing the in and out sets for all nodes.
+     */
+    calculateMopSolutionForwards(problem) {
+        let _out = problem.initOut;
+        let _in = problem.initIn;
+        let workList = problem.flowGraph.nodesInPostOrder;
+        let newEntries = new Set();
+        while (workList.length > 0) {
+            newEntries.clear();
+            workList.forEach((n) => {
+                let inSet;
+                const predecessors = problem.flowGraph.pred(n);
+                if (predecessors && predecessors.length > 0) {
+                    const predecessorOuts = predecessors.map((pred) => _out.get(pred));
+                    inSet = predecessorOuts.reduce((acc, cur) => problem.meet(acc, cur), problem.empty);
+                }
+                else {
+                    inSet = problem.empty;
+                }
+                _in.set(n, inSet);
+                let old = _out.get(n);
+                let newSet = problem.transferFunction.apply(n, inSet);
+                if (!old || old.count() === 0 || !old.equals(newSet)) {
+                    _out.set(n, newSet);
+                    problem.flowGraph.succ(n).forEach((succ) => newEntries.add(succ));
+                }
+            });
+            workList = [...newEntries];
+        }
+        return new Solution(_in, _out, problem);
+    }
+    /**
+     * Computes the MFP solution for a backward data flow analysis problem.
+     *
+     * @template Node - The type of nodes in the graph.
+     * @template V - The type of data flow values.
+     * @param problem - The data flow problem to solve.
+     * @returns The solution containing the in and out sets for all nodes.
+     */
+    calculateMopSolutionBackwards(problem) {
+        let _out = problem.initOut;
+        let _in = problem.initIn;
+        let workList = problem.flowGraph.nodesInPostOrder;
+        let newEntries = new Set();
+        while (workList.length > 0) {
+            newEntries.clear();
+            workList.forEach((n) => {
+                let outSet = problem.flowGraph.succ(n).reduce((acc, curr) => {
+                    return problem.meet(acc, _in.get(curr));
+                }, problem.empty);
+                _out.set(n, outSet);
+                let old = _in.get(n);
+                let newSet = problem.transferFunction.apply(n, outSet);
+                if (!old || !old.equals(newSet)) {
+                    _in.set(n, newSet);
+                    problem.flowGraph.pred(n).forEach((pred) => newEntries.add(pred));
+                }
+            });
+            workList = [...newEntries];
+        }
+        return new Solution(_in, _out, problem);
+    }
+}
+exports.MFPDataFlowSolver = MFPDataFlowSolver;

package/lib/core/dataflow/ReachingDef.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Reaching Definitions Data Flow Analysis
+ *
+ * This module implements the Reaching Definitions data flow analysis algorithm.
+ * Reaching Definitions is a forward data flow analysis that determines, for each
+ * program point, the set of variable definitions (assignments) that may reach
+ * that point without being overwritten.
+ *
+ * Key Components:
+ * 1. **Transfer Function**:
+ *    - Computes the out set for each node based on its in set.
+ *    - Uses gen and kill sets to model the effects of assignments:
+ *      - **gen**: The set of definitions generated by the current node.
+ *      - **kill**: The set of definitions killed (overwritten) by the current node.
+ *
+ * 2. **Meet Operation**:
+ *    - Combines data flow values from multiple paths (e.g., union for reaching definitions).
+ *    - Ensures that the analysis is conservative (safe) by over-approximating the result.
+ *
+ *  The analysis is forward, meaning it propagates information from predecessors to successors.
+ *
+ */
+import { Stmt } from '../base/Stmt';
+import { BaseImplicitGraph, NodeID } from '../graph/BaseImplicitGraph';
+import { ArkMethod } from '../model/ArkMethod';
+import { DataFlowProblem, TransferFunction, FlowGraph } from './GenericDataFlow';
+import { SparseBitVector } from '../../utils/SparseBitVector';
+type RDNode = Stmt;
+type DFNodeCollection = SparseBitVector;
+export declare class ReachingDefProblem implements DataFlowProblem<NodeID, DFNodeCollection> {
+    flowGraph: ReachingDefFlowGraph;
+    transferFunction: ReachingDefTransferFunction;
+    meet: (a: DFNodeCollection, b: DFNodeCollection) => DFNodeCollection;
+    initIn: Map<NodeID, DFNodeCollection>;
+    initOut: Map<NodeID, DFNodeCollection>;
+    forward: boolean;
+    empty: DFNodeCollection;
+    constructor(method: ArkMethod, forward?: boolean);
+}
+/**
+ * Represents the control flow graph (CFG) for reaching definitions analysis.
+ * This class implements the FlowGraph interface and provides methods to retrieve
+ * successors and predecessors of nodes, as well as topological orderings of nodes.
+ */
+declare class ReachingDefFlowGraph extends BaseImplicitGraph<RDNode> implements FlowGraph<NodeID> {
+    nodesInPostOrder: NodeID[];
+    constructor(method: ArkMethod);
+    getGraphName(): string;
+    dumpNodes(): void;
+    private initSuccPred;
+}
+/**
+ * Represents the transfer function for reaching definitions analysis.
+ */
+export declare class ReachingDefTransferFunction implements TransferFunction<NodeID, DFNodeCollection> {
+    gen: DFNodeCollection;
+    kill: Map<NodeID, DFNodeCollection>;
+    constructor(flowGraph: ReachingDefFlowGraph);
+    apply(n: NodeID, x: DFNodeCollection): DFNodeCollection;
+    private initGenKill;
+}
+export {};
+//# sourceMappingURL=ReachingDef.d.ts.map

package/lib/core/dataflow/ReachingDef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReachingDef.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/ReachingDef.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAiB,IAAI,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,KAAK,MAAM,GAAG,IAAI,CAAC;AACnB,KAAK,gBAAgB,GAAG,eAAe,CAAC;AAIxC,qBAAa,kBAAmB,YAAW,eAAe,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAChF,SAAS,EAAE,oBAAoB,CAAC;IAChC,gBAAgB,EAAE,2BAA2B,CAAC;IAC9C,IAAI,EAAE,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,gBAAgB,KAAK,gBAAgB,CAAC;IACrE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACtC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,gBAAgB,CAAuB;gBAElC,MAAM,EAAE,SAAS,EAAE,OAAO,GAAE,OAAc;CAYzD;AAED;;;;GAIG;AACH,cAAM,oBAAqB,SAAQ,iBAAiB,CAAC,MAAM,CAAE,YAAW,SAAS,CAAC,MAAM,CAAC;IACrF,gBAAgB,EAAE,MAAM,EAAE,CAAC;gBAEf,MAAM,EAAE,SAAS;IAc7B,YAAY,IAAI,MAAM;IAItB,SAAS,IAAI,IAAI;IAIjB,OAAO,CAAC,YAAY;CAyCvB;AAED;;GAEG;AACH,qBAAa,2BAA4B,YAAW,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAC1F,GAAG,EAAE,gBAAgB,CAAC;IACtB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;gBAExB,SAAS,EAAE,oBAAoB;IAM3C,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,gBAAgB,GAAG,gBAAgB;IAevD,OAAO,CAAC,WAAW;CAsBtB"}

package/lib/core/dataflow/ReachingDef.js

@@ -0,0 +1,168 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReachingDefTransferFunction = exports.ReachingDefProblem = void 0;
+/**
+ * Reaching Definitions Data Flow Analysis
+ *
+ * This module implements the Reaching Definitions data flow analysis algorithm.
+ * Reaching Definitions is a forward data flow analysis that determines, for each
+ * program point, the set of variable definitions (assignments) that may reach
+ * that point without being overwritten.
+ *
+ * Key Components:
+ * 1. **Transfer Function**:
+ *    - Computes the out set for each node based on its in set.
+ *    - Uses gen and kill sets to model the effects of assignments:
+ *      - **gen**: The set of definitions generated by the current node.
+ *      - **kill**: The set of definitions killed (overwritten) by the current node.
+ *
+ * 2. **Meet Operation**:
+ *    - Combines data flow values from multiple paths (e.g., union for reaching definitions).
+ *    - Ensures that the analysis is conservative (safe) by over-approximating the result.
+ *
+ *  The analysis is forward, meaning it propagates information from predecessors to successors.
+ *
+ */
+const Stmt_1 = require("../base/Stmt");
+const BaseImplicitGraph_1 = require("../graph/BaseImplicitGraph");
+const SparseBitVector_1 = require("../../utils/SparseBitVector");
+let coCtor = SparseBitVector_1.SparseBitVector;
+const BV_SIZE = 32;
+class ReachingDefProblem {
+    constructor(method, forward = true) {
+        this.empty = new coCtor(BV_SIZE);
+        this.flowGraph = new ReachingDefFlowGraph(method);
+        this.transferFunction = new ReachingDefTransferFunction(this.flowGraph);
+        this.meet = (x, y) => {
+            let r = x.clone();
+            r.unionWith(y);
+            return r;
+        };
+        this.initIn = new Map(this.flowGraph.nodesInPostOrder.map((i) => [i, new coCtor(BV_SIZE)]));
+        this.initOut = new Map(this.flowGraph.nodesInPostOrder.map((i) => [i, new coCtor(BV_SIZE)]));
+        this.forward = forward;
+    }
+}
+exports.ReachingDefProblem = ReachingDefProblem;
+/**
+ * Represents the control flow graph (CFG) for reaching definitions analysis.
+ * This class implements the FlowGraph interface and provides methods to retrieve
+ * successors and predecessors of nodes, as well as topological orderings of nodes.
+ */
+class ReachingDefFlowGraph extends BaseImplicitGraph_1.BaseImplicitGraph {
+    constructor(method) {
+        super();
+        const cfg = method.getCfg();
+        if (!cfg) {
+            throw new Error('CFG not found');
+        }
+        const nodes = cfg.getStmts();
+        this.nodeToIdMap = new Map(nodes.map((x, i) => [x, i]));
+        this.nodesInPostOrder = nodes.map((_, i) => i);
+        this.initSuccPred(nodes, cfg);
+    }
+    getGraphName() {
+        return 'Reaching Definition Flow Graph';
+    }
+    dumpNodes() {
+        var _a;
+        (_a = this.nodeToIdMap) === null || _a === void 0 ? void 0 : _a.forEach((id, node) => console.log(id + ': ' + node.toString()));
+    }
+    initSuccPred(nodes, cfg) {
+        this.succMap = new Map();
+        this.predMap = new Map();
+        cfg.getBlocks().forEach((bb) => {
+            let stmts = bb.getStmts();
+            if (stmts.length === 0) {
+                return;
+            }
+            for (let i = 0; i < stmts.length - 1; i++) {
+                let c = this.nodeToIdMap.get(stmts[i]);
+                let n = this.nodeToIdMap.get(stmts[i + 1]);
+                this.succMap.set(c, [n]);
+                this.predMap.set(n, [c]);
+            }
+            let terminate = bb.getTail();
+            if (!terminate) {
+                throw new Error('cfg has no terminal');
+            }
+            bb.getSuccessors().forEach((succBB) => {
+                var _a, _b, _c, _d;
+                let head = succBB.getHead();
+                if (!head) {
+                    return;
+                }
+                let t = (_a = this.nodeToIdMap) === null || _a === void 0 ? void 0 : _a.get(terminate);
+                let h = (_b = this.nodeToIdMap) === null || _b === void 0 ? void 0 : _b.get(head);
+                // Terminate's succ
+                let succ = (_c = this.succMap.get(t)) !== null && _c !== void 0 ? _c : [];
+                succ.push(h);
+                this.succMap.set(t, succ);
+                // Head's pred
+                let pred = (_d = this.predMap.get(h)) !== null && _d !== void 0 ? _d : [];
+                pred.push(t);
+                this.predMap.set(h, pred);
+            });
+        });
+    }
+}
+/**
+ * Represents the transfer function for reaching definitions analysis.
+ */
+class ReachingDefTransferFunction {
+    constructor(flowGraph) {
+        this.gen = new coCtor(BV_SIZE);
+        this.kill = new Map();
+        this.initGenKill(flowGraph);
+    }
+    apply(n, x) {
+        const result = x.clone();
+        if (this.gen.test(n)) {
+            result.set(n);
+        }
+        const killSet = this.kill.get(n);
+        if (killSet) {
+            for (const item of killSet) {
+                result.reset(item);
+            }
+        }
+        return result;
+    }
+    initGenKill(g) {
+        let genValue2Nodes = new Map();
+        // Init Gen
+        g.getNodeToIdMap().forEach((id, node) => {
+            var _a;
+            if (node instanceof Stmt_1.ArkAssignStmt) {
+                let lop = node.getLeftOp();
+                let genNodes = (_a = genValue2Nodes.get(lop)) !== null && _a !== void 0 ? _a : new coCtor(BV_SIZE);
+                genNodes.set(id);
+                genValue2Nodes.set(lop, genNodes);
+                this.gen.set(id);
+            }
+        });
+        // Init Kill
+        genValue2Nodes.forEach((defNodes, v) => {
+            for (const i of defNodes) {
+                const killSet = defNodes.clone();
+                killSet.reset(i);
+                this.kill.set(i, killSet);
+            }
+        });
+    }
+}
+exports.ReachingDefTransferFunction = ReachingDefTransferFunction;