arkanalyzer 1.0.5

package/lib/callgraph/model/CallGraph.js

@@ -0,0 +1,339 @@
+"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.CallGraph = exports.CallGraphNode = exports.CallGraphEdge = exports.CSCallSite = exports.DynCallSite = exports.CallSite = exports.CallGraphNodeKind = void 0;
+const GraphPrinter_1 = require("../../save/GraphPrinter");
+const PrinterBuilder_1 = require("../../save/PrinterBuilder");
+const BaseGraph_1 = require("./BaseGraph");
+const Statistics_1 = require("../common/Statistics");
+var CallGraphNodeKind;
+(function (CallGraphNodeKind) {
+    CallGraphNodeKind[CallGraphNodeKind["real"] = 0] = "real";
+    CallGraphNodeKind[CallGraphNodeKind["vitual"] = 1] = "vitual";
+    CallGraphNodeKind[CallGraphNodeKind["intrinsic"] = 2] = "intrinsic";
+    CallGraphNodeKind[CallGraphNodeKind["constructor"] = 3] = "constructor";
+})(CallGraphNodeKind = exports.CallGraphNodeKind || (exports.CallGraphNodeKind = {}));
+class CallSite {
+    constructor(s, a, ce, cr) {
+        this.callStmt = s;
+        this.args = a;
+        this.calleeFuncID = ce;
+        this.callerFuncID = cr;
+    }
+}
+exports.CallSite = CallSite;
+class DynCallSite {
+    constructor(caller, s, a, ptcCallee) {
+        this.callerFuncID = caller;
+        this.callStmt = s;
+        this.args = a;
+        this.protentialCalleeFuncID = ptcCallee;
+    }
+}
+exports.DynCallSite = DynCallSite;
+class CSCallSite extends CallSite {
+    constructor(id, cs) {
+        super(cs.callStmt, cs.args, cs.calleeFuncID, cs.callerFuncID);
+        this.cid = id;
+    }
+}
+exports.CSCallSite = CSCallSite;
+class CallGraphEdge extends BaseGraph_1.BaseEdge {
+    // private callSiteID: CallSiteID;
+    constructor(src, dst) {
+        super(src, dst, 0);
+        this.directCalls = new Set();
+        this.specialCalls = new Set();
+        this.indirectCalls = new Set();
+        //this.callSiteID = csID;
+    }
+    addDirectCallSite(stmt) {
+        this.directCalls.add(stmt);
+    }
+    addSpecialCallSite(stmt) {
+        this.specialCalls.add(stmt);
+    }
+    addInDirectCallSite(stmt) {
+        this.indirectCalls.add(stmt);
+    }
+    getDotAttr() {
+        const indirectCallNums = this.indirectCalls.size;
+        const directCallNums = this.directCalls.size;
+        const specialCallNums = this.specialCalls.size;
+        if ([CallGraphNodeKind.intrinsic, CallGraphNodeKind.constructor].includes(this.getDstNode().getKind())) {
+            return '';
+        }
+        if (indirectCallNums != 0 && directCallNums == 0) {
+            return "color=red";
+        }
+        else if (specialCallNums != 0) {
+            return "color=yellow";
+        }
+        else if (indirectCallNums == 0 && directCallNums != 0) {
+            return "color=black";
+        }
+        else {
+            return "color=black";
+        }
+    }
+}
+exports.CallGraphEdge = CallGraphEdge;
+class CallGraphNode extends BaseGraph_1.BaseNode {
+    constructor(id, m, k = CallGraphNodeKind.real) {
+        super(id, k);
+        this.isSdkMethod = false;
+        this.isBlank = false;
+        this.method = m;
+    }
+    getMethod() {
+        return this.method;
+    }
+    setSdkMethod(v) {
+        this.isSdkMethod = v;
+    }
+    getIsSdkMethod() {
+        return this.isSdkMethod;
+    }
+    get isBlankMethod() {
+        return this.isBlank;
+    }
+    set isBlankMethod(is) {
+        this.isBlank = is;
+    }
+    getDotAttr() {
+        if ([CallGraphNodeKind.intrinsic, CallGraphNodeKind.constructor].includes(this.getKind())) {
+            return '';
+        }
+        return 'shape=box';
+    }
+    getDotLabel() {
+        let label = 'ID: ' + this.getID() + '\n';
+        label = label + this.getMethod().toString();
+        return label;
+    }
+}
+exports.CallGraphNode = CallGraphNode;
+class CallGraph extends BaseGraph_1.BaseGraph {
+    constructor(s) {
+        super();
+        this.idToCallSiteMap = new Map();
+        this.callSiteToIdMap = new Map();
+        this.stmtToCallSitemap = new Map();
+        this.stmtToDynCallSitemap = new Map();
+        this.methodToCGNodeMap = new Map();
+        this.callPairToEdgeMap = new Map();
+        this.callSiteNum = 0;
+        this.scene = s;
+        this.cgStat = new Statistics_1.CGStat();
+    }
+    getCallPairString(srcID, dstID) {
+        return `${srcID}-${dstID}`;
+    }
+    getCallEdgeByPair(srcID, dstID) {
+        let key = this.getCallPairString(srcID, dstID);
+        return this.callPairToEdgeMap.get(key);
+    }
+    addCallGraphNode(method, kind = CallGraphNodeKind.real) {
+        let id = this.nodeNum;
+        let cgNode = new CallGraphNode(id, method, kind);
+        // check if sdk method
+        cgNode.setSdkMethod(this.scene.getSdkArkFilesMap().has(method.getDeclaringClassSignature().getDeclaringFileSignature().toString()));
+        let arkMethod = this.scene.getMethod(method);
+        if (!arkMethod || !arkMethod.getCfg()) {
+            cgNode.isBlankMethod = true;
+        }
+        this.addNode(cgNode);
+        this.methodToCGNodeMap.set(method.toString(), cgNode.getID());
+        this.cgStat.addNodeStat(kind);
+        return cgNode;
+    }
+    removeCallGraphNode(nodeID) {
+        // remove edge relate to node first
+        this.removeCallGraphEdge(nodeID);
+        let node = this.getNode(nodeID);
+        // remove node itself
+        this.removeNode(nodeID);
+        this.methodToCGNodeMap.delete(node.getMethod().toString());
+    }
+    getCallGraphNodeByMethod(method) {
+        if (!method) {
+            throw new Error();
+        }
+        let n = this.methodToCGNodeMap.get(method.toString());
+        if (n == undefined) {
+            // The method can't be found
+            // means the method has no implementation, or base type is unclear to find it
+            // Create a virtual CG Node
+            // TODO: this virtual CG Node need be remove once the base type is clear 
+            return this.addCallGraphNode(method, CallGraphNodeKind.vitual);
+        }
+        return this.getNode(n);
+    }
+    addDirectOrSpecialCallEdge(caller, callee, callStmt, isDirectCall = true) {
+        var _a;
+        let callerNode = this.getCallGraphNodeByMethod(caller);
+        let calleeNode = this.getCallGraphNodeByMethod(callee);
+        let args = (_a = callStmt.getInvokeExpr()) === null || _a === void 0 ? void 0 : _a.getArgs();
+        let cs = new CallSite(callStmt, args, calleeNode.getID(), callerNode.getID());
+        let csID;
+        if (!this.callSiteToIdMap.has(cs)) {
+            csID = this.callSiteNum++;
+            this.idToCallSiteMap.set(csID, cs);
+            this.callSiteToIdMap.set(cs, csID);
+        }
+        else {
+            csID = this.callSiteToIdMap.get(cs);
+        }
+        if (this.addStmtToCallSiteMap(callStmt, cs)) {
+            // TODO: check stmt exists
+        }
+        // TODO: check if edge exists 
+        let callEdge = this.getCallEdgeByPair(callerNode.getID(), calleeNode.getID());
+        if (callEdge == undefined) {
+            callEdge = new CallGraphEdge(callerNode, calleeNode);
+            callEdge.getSrcNode().addOutgoingEdge(callEdge);
+            callEdge.getDstNode().addIncomingEdge(callEdge);
+            this.callPairToEdgeMap.set(this.getCallPairString(callerNode.getID(), calleeNode.getID()), callEdge);
+        }
+        if (isDirectCall) {
+            callEdge.addDirectCallSite(callStmt);
+        }
+        else {
+            callEdge.addSpecialCallSite(callStmt);
+        }
+    }
+    removeCallGraphEdge(nodeID) {
+        let node = this.getNode(nodeID);
+        for (const inEdge of node.getIncomingEdge()) {
+            node.removeIncomingEdge(inEdge);
+        }
+        for (const outEdge of node.getOutgoingEdges()) {
+            node.removeIncomingEdge(outEdge);
+        }
+    }
+    addDynamicCallInfo(callStmt, caller, protentialCallee) {
+        var _a;
+        let callerNode = this.getCallGraphNodeByMethod(caller);
+        let calleeNode;
+        if (protentialCallee) {
+            calleeNode = this.getCallGraphNodeByMethod(protentialCallee);
+        }
+        let args = (_a = callStmt.getInvokeExpr()) === null || _a === void 0 ? void 0 : _a.getArgs();
+        let cs = new DynCallSite(callerNode.getID(), callStmt, args, calleeNode === null || calleeNode === void 0 ? void 0 : calleeNode.getID());
+        this.stmtToDynCallSitemap.set(callStmt, cs);
+    }
+    addDynamicCallEdge(callerID, calleeID, callStmt) {
+        let callerNode = this.getNode(callerID);
+        let calleeNode = this.getNode(calleeID);
+        let callEdge = this.getCallEdgeByPair(callerNode.getID(), calleeNode.getID());
+        if (callEdge == undefined) {
+            callEdge = new CallGraphEdge(callerNode, calleeNode);
+            callEdge.getSrcNode().addOutgoingEdge(callEdge);
+            callEdge.getDstNode().addIncomingEdge(callEdge);
+            this.callPairToEdgeMap.set(this.getCallPairString(callerNode.getID(), calleeNode.getID()), callEdge);
+        }
+        callEdge.addInDirectCallSite(callStmt);
+    }
+    getDynCallsiteByStmt(stmt) {
+        return this.stmtToDynCallSitemap.get(stmt);
+    }
+    addStmtToCallSiteMap(stmt, cs) {
+        if (this.stmtToCallSitemap.has(stmt)) {
+            return false;
+        }
+        this.stmtToCallSitemap.set(stmt, cs);
+        return true;
+    }
+    getCallSiteByStmt(stmt) {
+        return this.stmtToCallSitemap.get(stmt);
+    }
+    getDynEdges() {
+        let callMap = new Map();
+        this.callPairToEdgeMap.forEach((edge) => {
+            let srcMethod = edge.getSrcNode().getMethod();
+            let dstMethod = edge.getDstNode().getMethod();
+            let dstSet;
+            if (callMap.has(srcMethod)) {
+                dstSet = callMap.get(srcMethod);
+            }
+            else {
+                dstSet = new Set();
+            }
+            callMap.set(srcMethod, dstSet.add(dstMethod));
+        });
+        return callMap;
+    }
+    getMethodByFuncID(id) {
+        let node = this.getNode(id);
+        if (node != undefined) {
+            return node.getMethod();
+        }
+        //return undefined;
+        return null;
+    }
+    getArkMethodByFuncID(id) {
+        let method = this.getMethodByFuncID(id);
+        if (method != null) {
+            // TODO: SDK Method search
+            return this.scene.getMethod(method);
+        }
+        return null;
+    }
+    getEntries() {
+        return this.entries;
+    }
+    setEntries(n) {
+        this.entries = n;
+    }
+    dump(name, entry) {
+        let printer = new GraphPrinter_1.GraphPrinter(this);
+        if (entry) {
+            printer.setStartID(entry);
+        }
+        PrinterBuilder_1.PrinterBuilder.dump(printer, name);
+    }
+    detectReachable(fromID, dstID) {
+        let dWorklist = [];
+        let travserdFuncs = new Set();
+        dWorklist.push(fromID);
+        while (dWorklist.length > 0) {
+            let nodeID = dWorklist.shift();
+            if (travserdFuncs.has(nodeID)) {
+                continue;
+            }
+            travserdFuncs.add(nodeID);
+            let node = this.getNode(nodeID);
+            for (let e of node.getOutgoingEdges()) {
+                let dst = e.getDstID();
+                if (dst === dstID) {
+                    return true;
+                }
+                dWorklist.push(dst);
+            }
+        }
+        return false;
+    }
+    printStat() {
+        this.cgStat.printStat();
+    }
+    setDummyMainFuncID(dummyMainMethodID) {
+        this.dummyMainMethodID = dummyMainMethodID;
+    }
+    getDummyMainFuncID() {
+        return this.dummyMainMethodID;
+    }
+}
+exports.CallGraph = CallGraph;

package/lib/callgraph/model/builder/CallGraphBuilder.d.ts

@@ -0,0 +1,16 @@
+import { CallGraph, Method } from '../CallGraph';
+import { Scene } from '../../../Scene';
+import { ArkMethod } from '../../../core/model/ArkMethod';
+export declare class CallGraphBuilder {
+    private cg;
+    private scene;
+    constructor(c: CallGraph, s: Scene);
+    buildDirectCallGraphForScene(): void;
+    buildDirectCallGraph(methods: ArkMethod[]): void;
+    buildClassHierarchyCallGraph(entries: Method[], displayGeneratedMethod?: Boolean): void;
+    buildRapidTypeCallGraph(entries: Method[], displayGeneratedMethod?: Boolean): void;
+    private getDCCallee;
+    private isConstructor;
+    setEntries(): void;
+}
+//# sourceMappingURL=CallGraphBuilder.d.ts.map

package/lib/callgraph/model/builder/CallGraphBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallGraphBuilder.d.ts","sourceRoot":"","sources":["../../../../src/callgraph/model/builder/CallGraphBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,SAAS,EAAoC,MAAM,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAKvC,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAE1D,qBAAa,gBAAgB;IACzB,OAAO,CAAC,EAAE,CAAY;IACtB,OAAO,CAAC,KAAK,CAAQ;gBAET,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK;IAM3B,4BAA4B,IAAI,IAAI;IAQpC,oBAAoB,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,IAAI;IAyChD,4BAA4B,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,sBAAsB,GAAE,OAAe,GAAG,IAAI;IAW9F,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,sBAAsB,GAAE,OAAe,GAAG,IAAI;IAYhG,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,aAAa;IAId,UAAU,IAAI,IAAI;CAQ5B"}

package/lib/callgraph/model/builder/CallGraphBuilder.js

@@ -0,0 +1,106 @@
+"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.CallGraphBuilder = void 0;
+const CallGraph_1 = require("../CallGraph");
+const Expr_1 = require("../../../core/base/Expr");
+const ClassHierarchyAnalysis_1 = require("../../algorithm/ClassHierarchyAnalysis");
+const RapidTypeAnalysis_1 = require("../../algorithm/RapidTypeAnalysis");
+class CallGraphBuilder {
+    constructor(c, s) {
+        this.cg = c;
+        this.scene = s;
+    }
+    buildDirectCallGraphForScene() {
+        const methods = this.scene.getMethods();
+        this.buildDirectCallGraph(methods);
+        // set entries at end
+        this.setEntries();
+    }
+    buildDirectCallGraph(methods) {
+        var _a;
+        for (const method of methods) {
+            let m = method.getSignature();
+            let kind = CallGraph_1.CallGraphNodeKind.real;
+            if (method.isGenerated()) { // || method.getName() === '_DEFAULT_ARK_METHOD') {
+                kind = CallGraph_1.CallGraphNodeKind.intrinsic;
+            }
+            if (method.getName() === 'constructor') {
+                kind = CallGraph_1.CallGraphNodeKind.constructor;
+            }
+            this.cg.addCallGraphNode(m, kind);
+        }
+        for (const method of methods) {
+            let cfg = method.getCfg();
+            if (cfg === undefined) {
+                // abstract method cfg is undefined
+                continue;
+            }
+            let stmts = cfg.getStmts();
+            for (const stmt of stmts) {
+                let invokeExpr = stmt.getInvokeExpr();
+                if (invokeExpr == undefined) {
+                    continue;
+                }
+                let callee = this.getDCCallee(invokeExpr);
+                // abstract method will also be added into direct cg
+                if (callee && invokeExpr instanceof Expr_1.ArkStaticInvokeExpr) {
+                    this.cg.addDirectOrSpecialCallEdge(method.getSignature(), callee, stmt);
+                }
+                else if (callee && (invokeExpr instanceof Expr_1.ArkInstanceInvokeExpr && (this.isConstructor(callee) || ((_a = this.scene.getMethod(callee)) === null || _a === void 0 ? void 0 : _a.isGenerated())))) {
+                    this.cg.addDirectOrSpecialCallEdge(method.getSignature(), callee, stmt, false);
+                }
+                else {
+                    this.cg.addDynamicCallInfo(stmt, method.getSignature(), callee);
+                }
+            }
+        }
+    }
+    buildClassHierarchyCallGraph(entries, displayGeneratedMethod = false) {
+        let cgEntries = [];
+        entries.forEach((entry) => {
+            cgEntries.push(this.cg.getCallGraphNodeByMethod(entry).getID());
+        });
+        this.cg.setEntries(cgEntries);
+        let classHierarchyAnalysis = new ClassHierarchyAnalysis_1.ClassHierarchyAnalysis(this.scene, this.cg);
+        classHierarchyAnalysis.start(displayGeneratedMethod);
+    }
+    buildRapidTypeCallGraph(entries, displayGeneratedMethod = false) {
+        let cgEntries = [];
+        entries.forEach((entry) => {
+            cgEntries.push(this.cg.getCallGraphNodeByMethod(entry).getID());
+        });
+        this.cg.setEntries(cgEntries);
+        let rapidTypeAnalysis = new RapidTypeAnalysis_1.RapidTypeAnalysis(this.scene, this.cg);
+        rapidTypeAnalysis.start(displayGeneratedMethod);
+    }
+    /// Get direct call callee
+    getDCCallee(invokeExpr) {
+        return invokeExpr.getMethodSignature();
+    }
+    isConstructor(m) {
+        return m.getMethodSubSignature().getMethodName() === 'constructor';
+    }
+    setEntries() {
+        let nodesIter = this.cg.getNodesIter();
+        let entries = Array.from(nodesIter)
+            .filter(node => !node.hasIncomingEdges() && node.getKind() == CallGraph_1.CallGraphNodeKind.real
+            && !node.isBlankMethod)
+            .map(node => node.getID());
+        this.cg.setEntries(entries);
+    }
+}
+exports.CallGraphBuilder = CallGraphBuilder;

package/lib/callgraph/pointerAnalysis/Context.d.ts

@@ -0,0 +1,38 @@
+import { FuncID } from '../model/CallGraph';
+export type ContextID = number;
+export declare const DUMMY_CID = 0;
+declare class Context {
+    private contextElems;
+    static sEmptyCtx: Context;
+    constructor(contextElems?: number[]);
+    static newEmpty(): Context;
+    static new(contextElems: number[]): Context;
+    static newKLimitedContext(oldCtx: Context, elem: number, k: number): Context;
+    static kLimitedContext(ctx: Context, k: number): Context;
+    length(): number;
+    get(index: number): number;
+    toString(): String;
+}
+declare class ContextCache {
+    private contextList;
+    private contextToIDMap;
+    constructor();
+    getOrNewContextID(context: Context): ContextID;
+    updateContext(id: ContextID, newContext: Context, oldContext: Context): boolean;
+    getContextID(context: Context): ContextID | undefined;
+    getContext(id: number): Context | undefined;
+    getContextList(): Context[];
+}
+export declare class KLimitedContextSensitive {
+    k: number;
+    ctxCache: ContextCache;
+    constructor(k: number);
+    emptyContext(): Context;
+    getEmptyContextID(): ContextID;
+    getContextID(context: Context): ContextID;
+    getContextByID(context_id: number): Context | undefined;
+    getNewContextID(callerFuncId: FuncID): ContextID;
+    getOrNewContext(callerCid: ContextID, calleeFuncId: FuncID, findCalleeAsTop?: boolean): ContextID;
+}
+export {};
+//# sourceMappingURL=Context.d.ts.map

package/lib/callgraph/pointerAnalysis/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../../src/callgraph/pointerAnalysis/Context.ts"],"names":[],"mappings":"AAeA,OAAO,EAAC,MAAM,EAAC,MAAM,oBAAoB,CAAA;AAEzC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AAC9B,eAAO,MAAM,SAAS,IAAI,CAAA;AAE1B,cAAM,OAAO;IACT,OAAO,CAAC,YAAY,CAAW;IAC/B,MAAM,CAAC,SAAS,EAAE,OAAO,CAAmB;gBAEhC,YAAY,GAAE,MAAM,EAAO;IAIvC,MAAM,CAAC,QAAQ,IAAI,OAAO;IAI1B,MAAM,CAAC,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO;IAK3C,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAa5E,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAC,MAAM,GAAG,OAAO;IAShD,MAAM,IAAI,MAAM;IAIhB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAO1B,QAAQ,IAAI,MAAM;CAG5B;AAED,cAAM,YAAY;IACd,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,cAAc,CAAkC;;IAOjD,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS;IAa9C,aAAa,CAAC,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO;IAY/E,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS;IASrD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAQ3C,cAAc,IAAI,OAAO,EAAE;CAGrC;AAED,qBAAa,wBAAwB;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,YAAY,CAAC;gBAEX,CAAC,EAAE,MAAM;IAOd,YAAY,IAAI,OAAO;IAIvB,iBAAiB,IAAI,SAAS;IAI9B,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS;IAIzC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAIvD,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS;IAIhD,eAAe,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,eAAe,GAAE,OAAe,GAAG,SAAS;CAoBlH"}

package/lib/callgraph/pointerAnalysis/Context.js

@@ -0,0 +1,156 @@
+"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.KLimitedContextSensitive = exports.DUMMY_CID = void 0;
+exports.DUMMY_CID = 0;
+class Context {
+    constructor(contextElems = []) {
+        this.contextElems = contextElems;
+    }
+    static newEmpty() {
+        return new Context();
+    }
+    static new(contextElems) {
+        return new Context(contextElems);
+    }
+    // use old context and a new element to create a new k-limited Context 
+    static newKLimitedContext(oldCtx, elem, k) {
+        let elems = [];
+        if (k > 0) {
+            elems.push(elem);
+            if (oldCtx.contextElems.length < k) {
+                elems = elems.concat(oldCtx.contextElems);
+            }
+            else {
+                elems = elems.concat(oldCtx.contextElems.slice(0, k - 1));
+            }
+        }
+        return new Context(elems);
+    }
+    static kLimitedContext(ctx, k) {
+        if (ctx.length() <= k) {
+            return new Context(ctx.contextElems);
+        }
+        else {
+            const elems = ctx.contextElems.slice(0, k);
+            return new Context(elems);
+        }
+    }
+    length() {
+        return this.contextElems.length;
+    }
+    get(index) {
+        if (index < 0 || index >= this.contextElems.length) {
+            throw new Error('Index out of bounds');
+        }
+        return this.contextElems[index];
+    }
+    toString() {
+        return this.contextElems.join('-');
+    }
+}
+Context.sEmptyCtx = new Context([]);
+class ContextCache {
+    constructor() {
+        this.contextList = [];
+        this.contextToIDMap = new Map();
+        this.contextList = [];
+        this.contextToIDMap = new Map();
+    }
+    getOrNewContextID(context) {
+        let cStr = context.toString();
+        if (this.contextToIDMap.has(cStr)) {
+            return this.contextToIDMap.get(cStr);
+        }
+        else {
+            // real cid start from 1
+            const id = this.contextList.length;
+            this.contextList.push(context);
+            this.contextToIDMap.set(cStr, id);
+            return id;
+        }
+    }
+    updateContext(id, newContext, oldContext) {
+        if (this.contextList.length < id) {
+            return false;
+        }
+        this.contextList[id] = newContext;
+        let oldCStr = oldContext.toString();
+        let newCStr = newContext.toString();
+        this.contextToIDMap.delete(oldCStr);
+        this.contextToIDMap.set(newCStr, id);
+        return true;
+    }
+    getContextID(context) {
+        let cStr = context.toString();
+        if (this.contextToIDMap.has(cStr)) {
+            return this.contextToIDMap.get(cStr);
+        }
+        return undefined;
+    }
+    getContext(id) {
+        //if (id === 0 || id > this.contextList.length) {
+        if (id > this.contextList.length) {
+            return undefined;
+        }
+        return this.contextList[id];
+    }
+    getContextList() {
+        return this.contextList;
+    }
+}
+class KLimitedContextSensitive {
+    constructor(k) {
+        this.k = k;
+        this.ctxCache = new ContextCache();
+        // put dummy cid
+        this.getEmptyContextID();
+    }
+    emptyContext() {
+        return new Context([]);
+    }
+    getEmptyContextID() {
+        return this.getContextID(Context.newEmpty());
+    }
+    getContextID(context) {
+        return this.ctxCache.getOrNewContextID(context);
+    }
+    getContextByID(context_id) {
+        return this.ctxCache.getContext(context_id);
+    }
+    getNewContextID(callerFuncId) {
+        return this.ctxCache.getOrNewContextID(Context.new([callerFuncId]));
+    }
+    getOrNewContext(callerCid, calleeFuncId, findCalleeAsTop = false) {
+        const callerCtx = this.ctxCache.getContext(callerCid);
+        if (!callerCtx) {
+            throw new Error(`Context with id ${callerCid} not found.`);
+        }
+        const calleeNewCtx = Context.newKLimitedContext(callerCtx, calleeFuncId, this.k);
+        if (findCalleeAsTop) {
+            const calleeAsTopCtx = Context.newKLimitedContext(Context.sEmptyCtx, calleeFuncId, this.k);
+            let topID = this.ctxCache.getContextID(calleeAsTopCtx);
+            if (topID) {
+                // let ctx = this.ctxCache.getContext(topID);
+                this.ctxCache.updateContext(topID, calleeNewCtx, calleeAsTopCtx);
+                return topID;
+            }
+        }
+        const calleeCid = this.ctxCache.getOrNewContextID(calleeNewCtx);
+        return calleeCid;
+    }
+}
+exports.KLimitedContextSensitive = KLimitedContextSensitive;

package/lib/callgraph/pointerAnalysis/DummyCallCreator.d.ts

@@ -0,0 +1,23 @@
+import { Local } from '../../core/base/Local';
+import { Stmt } from '../../core/base/Stmt';
+import { ClassSignature } from '../../core/model/ArkSignature';
+import { Scene } from '../../Scene';
+/**
+ * TODO: constructor pointer and cid
+ */
+export declare class DummyCallCreator {
+    private scene;
+    private pageMap;
+    private componentMap;
+    constructor(scene: Scene);
+    getDummyCallByPage(classSig: ClassSignature, basePage: Local): Set<Stmt>;
+    getDummyCallByComponent(classSig: ClassSignature, baseComponent: Local): Set<Stmt>;
+    /**
+     * build dummy call edge with class signature, including a class new expr and call back function invokes
+     * @param classSig class signature
+     * @returns dummy call edges
+     */
+    private buildDummyCallBody;
+    private getComponentCallStmts;
+}
+//# sourceMappingURL=DummyCallCreator.d.ts.map

package/lib/callgraph/pointerAnalysis/DummyCallCreator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DummyCallCreator.d.ts","sourceRoot":"","sources":["../../../src/callgraph/pointerAnalysis/DummyCallCreator.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAiB,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAMpC;;GAEG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,OAAO,CAAC;IAEhB,OAAO,CAAC,YAAY,CAAiC;gBAEzC,KAAK,EAAE,KAAK;IAMjB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;IAYxE,uBAAuB,CAAC,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;IAYzF;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,qBAAqB;CAqBhC"}