arkanalyzer 1.0.5

package/lib/core/common/VisibleValue.js

@@ -0,0 +1,212 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = exports.VisibleValue = void 0;
+const logger_1 = __importStar(require("../../utils/logger"));
+const Local_1 = require("../base/Local");
+const Ref_1 = require("../base/Ref");
+const Stmt_1 = require("../base/Stmt");
+const Type_1 = require("../base/Type");
+const BasicBlock_1 = require("../graph/BasicBlock");
+const ArkClass_1 = require("../model/ArkClass");
+const ArkFile_1 = require("../model/ArkFile");
+const ArkMethod_1 = require("../model/ArkMethod");
+const ArkNamespace_1 = require("../model/ArkNamespace");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'VisibleValue');
+class VisibleValue {
+    constructor() {
+        // TODO:填充全局变量
+        this.currScope = new Scope([], 0);
+        this.scopeChain = [this.currScope];
+        this.currVisibleValues = [...this.currScope.values];
+    }
+    /** get values that is visible in curr scope */
+    getCurrVisibleValues() {
+        return this.currVisibleValues;
+    }
+    getScopeChain() {
+        return this.scopeChain;
+    }
+    /** udpate visible values after entered a scope, only support step by step */
+    updateIntoScope(model) {
+        let name = '';
+        if (model instanceof BasicBlock_1.BasicBlock) {
+            name = 'block: ' + model.toString();
+        }
+        else {
+            name = model.getName();
+        }
+        logger.info('---- into scope:{', name, '}');
+        // get values in this scope
+        let values = [];
+        if (model instanceof ArkFile_1.ArkFile || model instanceof ArkNamespace_1.ArkNamespace) {
+            values = this.getVisibleValuesIntoFileOrNameSpace(model);
+        }
+        else if (model instanceof ArkClass_1.ArkClass) {
+            values = this.getVisibleValuesIntoClass(model);
+        }
+        else if (model instanceof ArkMethod_1.ArkMethod) {
+            values = this.getVisibleValuesIntoMethod(model);
+        }
+        else if (model instanceof BasicBlock_1.BasicBlock) {
+            values = this.getVisibleValuesIntoBasicBlock(model);
+        }
+        // handle scope chain
+        const targetDepth = this.getTargetDepth(model);
+        this.addScope(values, targetDepth, model);
+    }
+    /** udpate visible values after left a scope, only support step by step */
+    updateOutScope() {
+        const currModel = this.currScope.arkModel;
+        let name = '';
+        if (currModel instanceof BasicBlock_1.BasicBlock) {
+            name = 'block: ' + currModel.toString();
+        }
+        else {
+            name = currModel.getName();
+        }
+        logger.info('---- out scope:{', name, '}');
+        let targetDepth = this.currScope.depth;
+        if (currModel instanceof BasicBlock_1.BasicBlock) {
+            const successorsCnt = currModel.getSuccessors().length;
+            // if successorsCnt <= 0, unchange
+            if (successorsCnt > 1) {
+                targetDepth += 1; // goto inner scope
+            }
+        }
+        this.deleteScope(targetDepth);
+    }
+    /** clear up previous scope */
+    deleteScope(targetDepth) {
+        const prevDepth = this.currScope.depth;
+        if (targetDepth > prevDepth) {
+            return;
+        }
+        let popScopeValuesCnt = 0;
+        let popScopeCnt = 0;
+        for (let i = this.scopeChain.length - 1; i >= 0; i--) {
+            if (this.scopeChain[i].depth < targetDepth) {
+                break;
+            }
+            popScopeCnt += 1;
+            popScopeValuesCnt += this.scopeChain[i].values.length;
+        }
+        this.scopeChain.splice(this.scopeChain.length - popScopeCnt, popScopeCnt)[0]; // popScopeCnt >= 1
+        this.currScope = this.scopeChain[this.scopeChain.length - 1];
+        const totalValuesCnt = this.currVisibleValues.length;
+        this.currVisibleValues.splice(totalValuesCnt - popScopeValuesCnt, popScopeValuesCnt);
+    }
+    /** add this scope to scope chain and update visible values */
+    addScope(values, targetDepth, model) {
+        const newScope = new Scope(values, targetDepth, model);
+        this.currScope = newScope;
+        this.scopeChain.push(this.currScope);
+        this.currVisibleValues.push(...this.currScope.values);
+    }
+    // TODO:构造嵌套关系树
+    getTargetDepth(model) {
+        const prevDepth = this.currScope.depth;
+        const prevModel = this.currScope.arkModel;
+        let targetDepth = prevDepth + 1;
+        if (model instanceof BasicBlock_1.BasicBlock) {
+            const predecessorsCnt = model.getPredecessors().length;
+            if (predecessorsCnt <= 1) {
+                targetDepth = prevDepth + 1;
+            }
+            else {
+                targetDepth = prevDepth;
+            }
+        }
+        else if ((model instanceof ArkFile_1.ArkFile) && (prevModel instanceof ArkFile_1.ArkFile)) {
+            targetDepth = prevDepth;
+        }
+        else if ((model instanceof ArkNamespace_1.ArkNamespace) && (prevModel instanceof ArkNamespace_1.ArkNamespace)) {
+            targetDepth = prevDepth;
+        }
+        else if ((model instanceof ArkClass_1.ArkClass) && (prevModel instanceof ArkClass_1.ArkClass)) {
+            targetDepth = prevDepth;
+        }
+        else if ((model instanceof ArkMethod_1.ArkMethod) && (prevModel instanceof ArkMethod_1.ArkMethod)) {
+            targetDepth = prevDepth;
+        }
+        return targetDepth;
+    }
+    getVisibleValuesIntoFileOrNameSpace(fileOrNameSpace) {
+        let values = [];
+        return values;
+    }
+    getVisibleValuesIntoClass(cls) {
+        const values = [];
+        const fields = cls.getFields();
+        const classSignature = cls.getSignature();
+        for (const field of fields) {
+            if (field.getModifiers().has('StaticKeyword')) {
+                const staticFieldRef = new Ref_1.ArkStaticFieldRef(field.getSignature());
+                values.push(staticFieldRef);
+            }
+            else {
+                const instanceFieldRef = new Ref_1.ArkInstanceFieldRef(new Local_1.Local('this', new Type_1.ClassType(classSignature)), field.getSignature());
+                values.push(instanceFieldRef);
+            }
+        }
+        return values;
+    }
+    getVisibleValuesIntoMethod(method) {
+        let visibleValues = [];
+        return visibleValues;
+    }
+    getVisibleValuesIntoBasicBlock(basiceBlock) {
+        const visibleValues = [];
+        for (const stmt of basiceBlock.getStmts()) {
+            if (stmt instanceof Stmt_1.ArkAssignStmt) {
+                visibleValues.push(stmt.getLeftOp());
+            }
+        }
+        return visibleValues;
+    }
+}
+exports.VisibleValue = VisibleValue;
+class Scope {
+    constructor(values, depth = -1, arkModel = null) {
+        this.values = values;
+        this.depth = depth;
+        this.arkModel = arkModel;
+    }
+}
+exports.Scope = Scope;

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

@@ -0,0 +1,21 @@
+import { Stmt } from '../base/Stmt';
+import { ArkMethod } from '../model/ArkMethod';
+export declare abstract class DataflowProblem<D> {
+    transferEdge(srcStmt: Stmt, tgtStmt: Stmt): void;
+    /**
+     * Transfer the outFact of srcStmt to the inFact of tgtStmt
+     *
+     * Return true if keeping progagation (i.e., tgtStmt will be added to the WorkList for further analysis)
+     */
+    abstract getNormalFlowFunction(srcStmt: Stmt, tgtStmt: Stmt): FlowFunction<D>;
+    abstract getCallFlowFunction(srcStmt: Stmt, method: ArkMethod): FlowFunction<D>;
+    abstract getExitToReturnFlowFunction(srcStmt: Stmt, tgtStmt: Stmt, callStmt: Stmt): FlowFunction<D>;
+    abstract getCallToReturnFlowFunction(srcStmt: Stmt, tgtStmt: Stmt): FlowFunction<D>;
+    abstract createZeroValue(): D;
+    abstract getEntryPoint(): Stmt;
+    abstract getEntryMethod(): ArkMethod;
+}
+export interface FlowFunction<D> {
+    getDataFacts(d: D): Set<D>;
+}
+//# sourceMappingURL=DataflowProblem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataflowProblem.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/DataflowProblem.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C,8BAAsB,eAAe,CAAC,CAAC;IAG5B,YAAY,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI;IAchD;;;;OAIG;IAWH,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAE5E,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAC,IAAI,EAAE,MAAM,EAAC,SAAS,GAAI,YAAY,CAAC,CAAC,CAAC;IAE9E,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,EAAE,QAAQ,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAEjG,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAElF,QAAQ,CAAC,eAAe,IAAK,CAAC;IAE9B,QAAQ,CAAC,aAAa,IAAK,IAAI;IAE/B,QAAQ,CAAC,cAAc,IAAK,SAAS;CACxC;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B,YAAY,CAAC,CAAC,EAAC,CAAC,GAAI,GAAG,CAAC,CAAC,CAAC,CAAC;CAC9B"}

package/lib/core/dataflow/DataflowProblem.js

@@ -0,0 +1,33 @@
+"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.DataflowProblem = void 0;
+const Edge_1 = require("./Edge");
+class DataflowProblem {
+    transferEdge(srcStmt, tgtStmt) {
+        let edgeKind = Edge_1.Edge.getKind(srcStmt, tgtStmt);
+        if (0 == edgeKind) {
+            //normal
+        }
+        else if (1 == edgeKind) { //Call-Edge
+        }
+        else if (2 == edgeKind) { //Return-Edge
+        }
+        else if (3 == edgeKind) { //Call-To-Return-Edge
+        }
+    }
+}
+exports.DataflowProblem = DataflowProblem;

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

@@ -0,0 +1,8 @@
+import { Stmt } from '../base/Stmt';
+import { Fact } from './Fact';
+export declare class DataflowResult {
+    stmt2InFacts: Map<Stmt, Fact>;
+    stmt2OutFacts: Map<Stmt, Fact>;
+    globalFacts: Set<Fact>;
+}
+//# sourceMappingURL=DataflowResult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataflowResult.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/DataflowResult.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,qBAAa,cAAc;IACvB,YAAY,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAyB;IACtD,aAAa,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAyB;IAGvD,WAAW,EAAE,GAAG,CAAC,IAAI,CAAC,CAAmB;CAC5C"}

package/lib/core/dataflow/DataflowResult.js

@@ -0,0 +1,26 @@
+"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.DataflowResult = void 0;
+class DataflowResult {
+    constructor() {
+        this.stmt2InFacts = new Map();
+        this.stmt2OutFacts = new Map();
+        //should we specifically keep global facts or just embedding them into the two maps above
+        this.globalFacts = new Set();
+    }
+}
+exports.DataflowResult = DataflowResult;

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

@@ -0,0 +1,40 @@
+import { Scene } from '../../Scene';
+import { ArkInvokeStmt, Stmt } from '../base/Stmt';
+import { ArkMethod } from '../model/ArkMethod';
+import { DataflowProblem } from './DataflowProblem';
+import { PathEdge } from './Edge';
+export declare abstract class DataflowSolver<D> {
+    private problem;
+    private workList;
+    private pathEdgeSet;
+    private zeroFact;
+    private inComing;
+    private endSummary;
+    private summaryEdge;
+    private scene;
+    private CHA;
+    private stmtNexts;
+    private laterEdges;
+    constructor(problem: DataflowProblem<D>, scene: Scene);
+    solve(): void;
+    protected computeResult(stmt: Stmt, d: D): boolean;
+    protected getChildren(stmt: Stmt): Stmt[];
+    protected init(): void;
+    private buildStmtMapInClass;
+    private buildStmtMap;
+    private setCfg4AllStmt;
+    protected getAllCalleeMethods(callNode: ArkInvokeStmt): Set<ArkMethod>;
+    protected getReturnSiteOfCall(call: Stmt): Stmt;
+    protected getStartOfCallerMethod(call: Stmt): Stmt;
+    protected pathEdgeSetHasEdge(edge: PathEdge<D>): boolean;
+    protected propagate(edge: PathEdge<D>): void;
+    protected processExitNode(edge: PathEdge<D>): void;
+    protected processNormalNode(edge: PathEdge<D>): void;
+    protected processCallNode(edge: PathEdge<D>): void;
+    protected doSolve(): void;
+    protected isCallStatement(stmt: Stmt): boolean;
+    protected isExitStatement(stmt: Stmt): boolean;
+    getPathEdgeSet(): Set<PathEdge<D>>;
+}
+export declare function factEqual<D>(fact1: D, fact2: D): boolean;
+//# sourceMappingURL=DataflowSolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataflowSolver.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/DataflowSolver.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,OAAO,EAAE,aAAa,EAAoC,IAAI,EAAE,MAAM,cAAc,CAAC;AAErF,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAgB,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAiB,MAAM,QAAQ,CAAC;AAmBjD,8BAAsB,cAAc,CAAC,CAAC;IAElC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,UAAU,CAA+B;gBAErC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK;IAa9C,KAAK;IAKZ,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO;IASlD,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE;IAIzC,SAAS,CAAC,IAAI;IAiBd,OAAO,CAAC,mBAAmB;IAyB3B,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,cAAc;IAQtB,SAAS,CAAC,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,GAAG,CAAC,SAAS,CAAC;IActE,SAAS,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAI/C,SAAS,CAAC,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAMlD,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAU9C,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAcrC,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IA0C3C,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAgB7C,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IA+D3C,SAAS,CAAC,OAAO;IAiBjB,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAc9C,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAIvC,cAAc,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CAG5C;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAKxD"}

package/lib/core/dataflow/DataflowSolver.js

@@ -0,0 +1,318 @@
+"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.factEqual = exports.DataflowSolver = void 0;
+const Expr_1 = require("../base/Expr");
+const Ref_1 = require("../base/Ref");
+const Stmt_1 = require("../base/Stmt");
+const Edge_1 = require("./Edge");
+const CallGraph_1 = require("../../callgraph/model/CallGraph");
+const CallGraphBuilder_1 = require("../../callgraph/model/builder/CallGraphBuilder");
+const ClassHierarchyAnalysis_1 = require("../../callgraph/algorithm/ClassHierarchyAnalysis");
+const entryMethodUtils_1 = require("../../utils/entryMethodUtils");
+const Util_1 = require("./Util");
+class DataflowSolver {
+    constructor(problem, scene) {
+        this.laterEdges = new Set();
+        this.problem = problem;
+        this.scene = scene;
+        scene.inferTypes();
+        this.zeroFact = problem.createZeroValue();
+        this.workList = new Array();
+        this.pathEdgeSet = new Set();
+        this.inComing = new Map();
+        this.endSummary = new Map();
+        this.summaryEdge = new Set();
+        this.stmtNexts = new Map();
+    }
+    solve() {
+        this.init();
+        this.doSolve();
+    }
+    computeResult(stmt, d) {
+        for (let pathEdge of this.pathEdgeSet) {
+            if (pathEdge.edgeEnd.node == stmt && pathEdge.edgeEnd.fact == d) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getChildren(stmt) {
+        return Array.from(this.stmtNexts.get(stmt) || []);
+    }
+    init() {
+        let edgePoint = new Edge_1.PathEdgePoint(this.problem.getEntryPoint(), this.zeroFact);
+        let edge = new Edge_1.PathEdge(edgePoint, edgePoint);
+        this.workList.push(edge);
+        this.pathEdgeSet.add(edge);
+        // build CHA
+        let cg = new CallGraph_1.CallGraph(this.scene);
+        let cgBuilder = new CallGraphBuilder_1.CallGraphBuilder(cg, this.scene);
+        cgBuilder.buildClassHierarchyCallGraph([this.problem.getEntryMethod().getSignature()]);
+        this.CHA = new ClassHierarchyAnalysis_1.ClassHierarchyAnalysis(this.scene, cg);
+        // this.CHA = this.scene.makeCallGraphCHA([this.problem.getEntryMethod().getSignature()]) as ClassHierarchyAnalysisAlgorithm;
+        this.buildStmtMap();
+        this.setCfg4AllStmt();
+        return;
+    }
+    buildStmtMapInClass(clas) {
+        for (const method of clas.getMethods(true)) {
+            const cfg = method.getCfg();
+            const blocks = [];
+            if (cfg) {
+                blocks.push(...cfg.getBlocks());
+            }
+            for (const block of blocks) {
+                const stmts = block.getStmts();
+                for (let stmtIndex = 0; stmtIndex < stmts.length; stmtIndex++) {
+                    const stmt = stmts[stmtIndex];
+                    if (stmtIndex != stmts.length - 1) {
+                        this.stmtNexts.set(stmt, new Set([stmts[stmtIndex + 1]]));
+                    }
+                    else {
+                        const set = new Set();
+                        for (const successor of block.getSuccessors()) {
+                            set.add(successor.getStmts()[0]);
+                        }
+                        this.stmtNexts.set(stmt, set);
+                    }
+                }
+            }
+        }
+    }
+    buildStmtMap() {
+        for (const classes of this.scene.getClassMap()) {
+            for (const cls of classes[1]) {
+                this.buildStmtMapInClass(cls);
+            }
+        }
+    }
+    setCfg4AllStmt() {
+        for (const cls of this.scene.getClasses()) {
+            for (const mtd of cls.getMethods(true)) {
+                (0, entryMethodUtils_1.addCfg2Stmt)(mtd);
+            }
+        }
+    }
+    getAllCalleeMethods(callNode) {
+        // const methodSignatures = this.CHA.resolveCall(this.problem.getEntryMethod().getSignature(), callNode);
+        const callSites = this.CHA.resolveCall(this.CHA.getCallGraph().getCallGraphNodeByMethod(this.problem.getEntryMethod().getSignature()).getID(), callNode);
+        const methods = new Set();
+        for (const callSite of callSites) {
+            const method = this.scene.getMethod(this.CHA.getCallGraph().getMethodByFuncID(callSite.calleeFuncID));
+            if (method) {
+                methods.add(method);
+            }
+        }
+        return methods;
+    }
+    getReturnSiteOfCall(call) {
+        return [...this.stmtNexts.get(call)][0];
+    }
+    getStartOfCallerMethod(call) {
+        const cfg = call.getCfg();
+        const paraNum = cfg.getDeclaringMethod().getParameters().length;
+        return [...cfg.getBlocks()][0].getStmts()[paraNum];
+    }
+    pathEdgeSetHasEdge(edge) {
+        for (const path of this.pathEdgeSet) {
+            if (path.edgeEnd.node == edge.edgeEnd.node && factEqual(path.edgeEnd.fact, edge.edgeEnd.fact) &&
+                path.edgeStart.node == edge.edgeStart.node && factEqual(path.edgeStart.fact, edge.edgeStart.fact)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    propagate(edge) {
+        if (!this.pathEdgeSetHasEdge(edge)) {
+            let index = this.workList.length;
+            for (let i = 0; i < this.workList.length; i++) {
+                if (this.laterEdges.has(this.workList[i])) {
+                    index = i;
+                    break;
+                }
+            }
+            this.workList.splice(index, 0, edge);
+            this.pathEdgeSet.add(edge);
+        }
+    }
+    processExitNode(edge) {
+        var _a;
+        let startEdgePoint = edge.edgeStart;
+        let exitEdgePoint = edge.edgeEnd;
+        const summary = this.endSummary.get(startEdgePoint);
+        if (summary == undefined) {
+            this.endSummary.set(startEdgePoint, new Set([exitEdgePoint]));
+        }
+        else {
+            summary.add(exitEdgePoint);
+        }
+        const callEdgePoints = this.inComing.get(startEdgePoint);
+        if (callEdgePoints == undefined) {
+            if (startEdgePoint.node.getCfg().getDeclaringMethod() == this.problem.getEntryMethod()) {
+                return;
+            }
+            throw new Error('incoming does not have ' + ((_a = startEdgePoint.node.getCfg()) === null || _a === void 0 ? void 0 : _a.getDeclaringMethod().toString()));
+        }
+        for (let callEdgePoint of callEdgePoints) {
+            let returnSite = this.getReturnSiteOfCall(callEdgePoint.node);
+            let returnFlowFunc = this.problem.getExitToReturnFlowFunction(exitEdgePoint.node, returnSite, callEdgePoint.node);
+            for (let fact of returnFlowFunc.getDataFacts(exitEdgePoint.fact)) {
+                let returnSitePoint = new Edge_1.PathEdgePoint(returnSite, fact);
+                let cacheEdge = new Edge_1.PathEdge(callEdgePoint, returnSitePoint);
+                let summaryEdgeHasCacheEdge = false;
+                for (const sEdge of this.summaryEdge) {
+                    if (sEdge.edgeStart == callEdgePoint && sEdge.edgeEnd.node == returnSite && sEdge.edgeEnd.fact == fact) {
+                        summaryEdgeHasCacheEdge = true;
+                        break;
+                    }
+                }
+                if (!summaryEdgeHasCacheEdge) {
+                    this.summaryEdge.add(cacheEdge);
+                    let startOfCaller = this.getStartOfCallerMethod(callEdgePoint.node);
+                    for (let pathEdge of this.pathEdgeSet) {
+                        if (pathEdge.edgeStart.node == startOfCaller && pathEdge.edgeEnd == callEdgePoint) {
+                            this.propagate(new Edge_1.PathEdge(pathEdge.edgeStart, returnSitePoint));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    processNormalNode(edge) {
+        let start = edge.edgeStart;
+        let end = edge.edgeEnd;
+        let stmts = [...this.getChildren(end.node)].reverse();
+        for (let stmt of stmts) {
+            let flowFunction = this.problem.getNormalFlowFunction(end.node, stmt);
+            let set = flowFunction.getDataFacts(end.fact);
+            for (let fact of set) {
+                let edgePoint = new Edge_1.PathEdgePoint(stmt, fact);
+                const edge = new Edge_1.PathEdge(start, edgePoint);
+                this.propagate(edge);
+                this.laterEdges.add(edge);
+            }
+        }
+    }
+    processCallNode(edge) {
+        let start = edge.edgeStart;
+        let callEdgePoint = edge.edgeEnd;
+        const invokeStmt = callEdgePoint.node;
+        let callees;
+        if (this.scene.getFilesMap().get(invokeStmt.getInvokeExpr().getMethodSignature().getDeclaringClassSignature().getDeclaringFileSignature().toString())) {
+            callees = this.getAllCalleeMethods(callEdgePoint.node);
+        }
+        else {
+            callees = new Set([(0, Util_1.getRecallMethodInParam)(invokeStmt)]);
+        }
+        let callNode = edge.edgeEnd.node;
+        let returnSite = this.getReturnSiteOfCall(callEdgePoint.node);
+        for (let callee of callees) {
+            let callFlowFunc = this.problem.getCallFlowFunction(callNode, callee);
+            if (!callee.getCfg()) {
+                continue;
+            }
+            let firstStmt = [...callee.getCfg().getBlocks()][0].getStmts()[callee.getParameters().length];
+            let facts = callFlowFunc.getDataFacts(callEdgePoint.fact);
+            for (let fact of facts) {
+                // method start loop path edge
+                let startEdgePoint = new Edge_1.PathEdgePoint(firstStmt, fact);
+                this.propagate(new Edge_1.PathEdge(startEdgePoint, startEdgePoint));
+                //add callEdgePoint in inComing.get(startEdgePoint)
+                let coming = undefined;
+                for (const incoming of this.inComing.keys()) {
+                    if (incoming.fact == startEdgePoint.fact && incoming.node == startEdgePoint.node) {
+                        coming = this.inComing.get(incoming);
+                        break;
+                    }
+                }
+                if (coming == undefined) {
+                    this.inComing.set(startEdgePoint, new Set([callEdgePoint]));
+                }
+                else {
+                    coming.add(callEdgePoint);
+                }
+                let exitEdgePoints = new Set();
+                for (const end of Array.from(this.endSummary.keys())) {
+                    if (end.fact == fact && end.node == firstStmt) {
+                        exitEdgePoints = this.endSummary.get(end);
+                    }
+                }
+                for (let exitEdgePoint of exitEdgePoints) {
+                    let returnFlowFunc = this.problem.getExitToReturnFlowFunction(exitEdgePoint.node, returnSite, callEdgePoint.node);
+                    for (let returnFact of returnFlowFunc.getDataFacts(exitEdgePoint.fact)) {
+                        this.summaryEdge.add(new Edge_1.PathEdge(edge.edgeEnd, new Edge_1.PathEdgePoint(returnSite, returnFact)));
+                    }
+                }
+            }
+        }
+        let callToReturnflowFunc = this.problem.getCallToReturnFlowFunction(edge.edgeEnd.node, returnSite);
+        let set = callToReturnflowFunc.getDataFacts(callEdgePoint.fact);
+        for (let fact of set) {
+            this.propagate(new Edge_1.PathEdge(start, new Edge_1.PathEdgePoint(returnSite, fact)));
+        }
+        for (let cacheEdge of this.summaryEdge) {
+            if (cacheEdge.edgeStart == edge.edgeEnd && cacheEdge.edgeEnd.node == returnSite) {
+                this.propagate(new Edge_1.PathEdge(start, cacheEdge.edgeEnd));
+            }
+        }
+    }
+    doSolve() {
+        while (this.workList.length != 0) {
+            let pathEdge = this.workList.shift();
+            if (this.laterEdges.has(pathEdge)) {
+                this.laterEdges.delete(pathEdge);
+            }
+            let targetStmt = pathEdge.edgeEnd.node;
+            if (this.isCallStatement(targetStmt)) {
+                this.processCallNode(pathEdge);
+            }
+            else if (this.isExitStatement(targetStmt)) {
+                this.processExitNode(pathEdge);
+            }
+            else {
+                this.processNormalNode(pathEdge);
+            }
+        }
+    }
+    isCallStatement(stmt) {
+        for (const expr of stmt.getExprs()) {
+            if (expr instanceof Expr_1.AbstractInvokeExpr) {
+                if (this.scene.getFilesMap().get(expr.getMethodSignature().getDeclaringClassSignature().getDeclaringFileSignature().toString())) {
+                    return true;
+                }
+                if (stmt instanceof Stmt_1.ArkInvokeStmt && (0, Util_1.getRecallMethodInParam)(stmt)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    isExitStatement(stmt) {
+        return stmt instanceof Stmt_1.ArkReturnStmt || stmt instanceof Stmt_1.ArkReturnVoidStmt;
+    }
+    getPathEdgeSet() {
+        return this.pathEdgeSet;
+    }
+}
+exports.DataflowSolver = DataflowSolver;
+function factEqual(fact1, fact2) {
+    if (fact1 instanceof Ref_1.AbstractRef && fact2 instanceof Ref_1.AbstractRef) {
+        return fact1.toString() == fact2.toString();
+    }
+    return fact1 == fact2;
+}
+exports.factEqual = factEqual;