arkanalyzer 1.0.20 → 1.0.21

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

@@ -1,16 +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;
-}
+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.js

@@ -1,106 +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()) {
-                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;
+"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()) {
+                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

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

@@ -1,155 +1,155 @@
-"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) {
-                this.ctxCache.updateContext(topID, calleeNewCtx, calleeAsTopCtx);
-                return topID;
-            }
-        }
-        const calleeCid = this.ctxCache.getOrNewContextID(calleeNewCtx);
-        return calleeCid;
-    }
-}
-exports.KLimitedContextSensitive = KLimitedContextSensitive;
+"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) {
+                this.ctxCache.updateContext(topID, calleeNewCtx, calleeAsTopCtx);
+                return topID;
+            }
+        }
+        const calleeCid = this.ctxCache.getOrNewContextID(calleeNewCtx);
+        return calleeCid;
+    }
+}
+exports.KLimitedContextSensitive = KLimitedContextSensitive;