arkanalyzer 1.0.20 → 1.0.21

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

@@ -1,63 +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 {};
+/**
+ * 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.js

@@ -1,168 +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;
+"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;

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

@@ -1,46 +1,46 @@
-import { Scene } from '../../Scene';
-import { DataflowProblem, FlowFunction } from './DataflowProblem';
-import { Local } from '../base/Local';
-import { Value } from '../base/Value';
-import { ArkAssignStmt, Stmt } from '../base/Stmt';
-import { ArkMethod } from '../model/ArkMethod';
-import { Constant } from '../base/Constant';
-import { DataflowSolver } from './DataflowSolver';
-import { FileSignature, NamespaceSignature } from '../model/ArkSignature';
-import { ArkClass } from '../model/ArkClass';
-import { ArkField } from '../model/ArkField';
-export declare class UndefinedVariableChecker extends DataflowProblem<Value> {
-    zeroValue: Constant;
-    entryPoint: Stmt;
-    entryMethod: ArkMethod;
-    scene: Scene;
-    classMap: Map<FileSignature | NamespaceSignature, ArkClass[]>;
-    globalVariableMap: Map<FileSignature | NamespaceSignature, Local[]>;
-    outcomes: Outcome[];
-    constructor(stmt: Stmt, method: ArkMethod);
-    getEntryPoint(): Stmt;
-    getEntryMethod(): ArkMethod;
-    private isUndefined;
-    getNormalFlowFunction(srcStmt: Stmt, tgtStmt: Stmt): FlowFunction<Value>;
-    insideNormalFlowFunction(ret: Set<Value>, srcStmt: ArkAssignStmt, dataFact: Value): void;
-    getCallFlowFunction(srcStmt: Stmt, method: ArkMethod): FlowFunction<Value>;
-    insideCallFlowFunction(ret: Set<Value>, method: ArkMethod): void;
-    addUndefinedField(field: ArkField, method: ArkMethod, ret: Set<Value>): void;
-    addParameters(srcStmt: Stmt, dataFact: Value, method: ArkMethod, ret: Set<Value>): void;
-    getExitToReturnFlowFunction(srcStmt: Stmt, tgtStmt: Stmt, callStmt: Stmt): FlowFunction<Value>;
-    getCallToReturnFlowFunction(srcStmt: Stmt, tgtStmt: Stmt): FlowFunction<Value>;
-    createZeroValue(): Value;
-    getZeroValue(): Value;
-    factEqual(d1: Value, d2: Value): boolean;
-    getOutcomes(): Outcome[];
-}
-export declare class UndefinedVariableSolver extends DataflowSolver<Value> {
-    constructor(problem: UndefinedVariableChecker, scene: Scene);
-}
-declare class Outcome {
-    value: Value;
-    stmt: Stmt;
-    constructor(v: Value, s: Stmt);
-}
-export {};
+import { Scene } from '../../Scene';
+import { DataflowProblem, FlowFunction } from './DataflowProblem';
+import { Local } from '../base/Local';
+import { Value } from '../base/Value';
+import { ArkAssignStmt, Stmt } from '../base/Stmt';
+import { ArkMethod } from '../model/ArkMethod';
+import { Constant } from '../base/Constant';
+import { DataflowSolver } from './DataflowSolver';
+import { FileSignature, NamespaceSignature } from '../model/ArkSignature';
+import { ArkClass } from '../model/ArkClass';
+import { ArkField } from '../model/ArkField';
+export declare class UndefinedVariableChecker extends DataflowProblem<Value> {
+    zeroValue: Constant;
+    entryPoint: Stmt;
+    entryMethod: ArkMethod;
+    scene: Scene;
+    classMap: Map<FileSignature | NamespaceSignature, ArkClass[]>;
+    globalVariableMap: Map<FileSignature | NamespaceSignature, Local[]>;
+    outcomes: Outcome[];
+    constructor(stmt: Stmt, method: ArkMethod);
+    getEntryPoint(): Stmt;
+    getEntryMethod(): ArkMethod;
+    private isUndefined;
+    getNormalFlowFunction(srcStmt: Stmt, tgtStmt: Stmt): FlowFunction<Value>;
+    insideNormalFlowFunction(ret: Set<Value>, srcStmt: ArkAssignStmt, dataFact: Value): void;
+    getCallFlowFunction(srcStmt: Stmt, method: ArkMethod): FlowFunction<Value>;
+    insideCallFlowFunction(ret: Set<Value>, method: ArkMethod): void;
+    addUndefinedField(field: ArkField, method: ArkMethod, ret: Set<Value>): void;
+    addParameters(srcStmt: Stmt, dataFact: Value, method: ArkMethod, ret: Set<Value>): void;
+    getExitToReturnFlowFunction(srcStmt: Stmt, tgtStmt: Stmt, callStmt: Stmt): FlowFunction<Value>;
+    getCallToReturnFlowFunction(srcStmt: Stmt, tgtStmt: Stmt): FlowFunction<Value>;
+    createZeroValue(): Value;
+    getZeroValue(): Value;
+    factEqual(d1: Value, d2: Value): boolean;
+    getOutcomes(): Outcome[];
+}
+export declare class UndefinedVariableSolver extends DataflowSolver<Value> {
+    constructor(problem: UndefinedVariableChecker, scene: Scene);
+}
+declare class Outcome {
+    value: Value;
+    stmt: Stmt;
+    constructor(v: Value, s: Stmt);
+}
+export {};
 //# sourceMappingURL=UndefinedVariable.d.ts.map