arkanalyzer 1.0.5

package/lib/callgraph/pointerAnalysis/Pag.js

@@ -0,0 +1,774 @@
+"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.FuncPag = exports.Pag = exports.PagGlobalThisNode = exports.PagFuncNode = exports.PagParamNode = exports.PagNewArrayExprNode = exports.PagNewExprNode = exports.PagArrayNode = exports.PagThisRefNode = exports.PagStaticFieldNode = exports.PagInstanceFieldNode = exports.PagLocalNode = exports.PagNode = exports.PagNodeKind = exports.ThisPagEdge = exports.WritePagEdge = exports.LoadPagEdge = exports.CopyPagEdge = exports.AddrPagEdge = exports.PagEdge = exports.GLOBAL_THIS = exports.PagEdgeKind = void 0;
+const BaseGraph_1 = require("../model/BaseGraph");
+const Stmt_1 = require("../../core/base/Stmt");
+const Expr_1 = require("../../core/base/Expr");
+const Ref_1 = require("../../core/base/Ref");
+const Local_1 = require("../../core/base/Local");
+const GraphPrinter_1 = require("../../save/GraphPrinter");
+const PrinterBuilder_1 = require("../../save/PrinterBuilder");
+const Constant_1 = require("../../core/base/Constant");
+const Type_1 = require("../../core/base/Type");
+const logger_1 = __importStar(require("../../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'PTA');
+/*
+ * Implementation of pointer-to assignment graph for pointer analysis
+ */
+const DUMMY_PAG_NODE_ID = -1;
+var PagEdgeKind;
+(function (PagEdgeKind) {
+    PagEdgeKind[PagEdgeKind["Address"] = 0] = "Address";
+    PagEdgeKind[PagEdgeKind["Copy"] = 1] = "Copy";
+    PagEdgeKind[PagEdgeKind["Load"] = 2] = "Load";
+    PagEdgeKind[PagEdgeKind["Write"] = 3] = "Write";
+    PagEdgeKind[PagEdgeKind["This"] = 4] = "This";
+    PagEdgeKind[PagEdgeKind["Unknown"] = 5] = "Unknown";
+})(PagEdgeKind = exports.PagEdgeKind || (exports.PagEdgeKind = {}));
+;
+exports.GLOBAL_THIS = 'globaThis';
+class PagEdge extends BaseGraph_1.BaseEdge {
+    constructor(n, d, k, s) {
+        super(n, d, k);
+        this.stmt = s;
+    }
+    ;
+    getDotAttr() {
+        var _a;
+        switch (this.getKind()) {
+            case PagEdgeKind.Address:
+                return "color=green";
+            case PagEdgeKind.Copy:
+                if (((_a = this.stmt) === null || _a === void 0 ? void 0 : _a.getInvokeExpr()) != undefined || this.stmt instanceof Stmt_1.ArkReturnStmt) {
+                    return "color=black,style=dotted";
+                }
+                return "color=black";
+            case PagEdgeKind.Load:
+                return "color=red";
+            case PagEdgeKind.Write:
+                return "color=blue";
+            case PagEdgeKind.This:
+                return "color=orange";
+            default:
+                return "color=black";
+        }
+    }
+}
+exports.PagEdge = PagEdge;
+class AddrPagEdge extends PagEdge {
+    constructor(n, d, s) {
+        super(n, d, PagEdgeKind.Address, s);
+    }
+    ;
+}
+exports.AddrPagEdge = AddrPagEdge;
+class CopyPagEdge extends PagEdge {
+    constructor(n, d, s) {
+        super(n, d, PagEdgeKind.Copy, s);
+    }
+    ;
+}
+exports.CopyPagEdge = CopyPagEdge;
+class LoadPagEdge extends PagEdge {
+    constructor(n, d, s) {
+        super(n, d, PagEdgeKind.Copy, s);
+    }
+    ;
+}
+exports.LoadPagEdge = LoadPagEdge;
+class WritePagEdge extends PagEdge {
+    constructor(n, d, s) {
+        super(n, d, PagEdgeKind.Write, s);
+    }
+    ;
+}
+exports.WritePagEdge = WritePagEdge;
+class ThisPagEdge extends PagEdge {
+    constructor(n, d, s) {
+        super(n, d, PagEdgeKind.This, s);
+    }
+    ;
+}
+exports.ThisPagEdge = ThisPagEdge;
+var PagNodeKind;
+(function (PagNodeKind) {
+    PagNodeKind[PagNodeKind["HeapObj"] = 0] = "HeapObj";
+    PagNodeKind[PagNodeKind["LocalVar"] = 1] = "LocalVar";
+    PagNodeKind[PagNodeKind["RefVar"] = 2] = "RefVar";
+    PagNodeKind[PagNodeKind["Param"] = 3] = "Param";
+    PagNodeKind[PagNodeKind["ThisRef"] = 4] = "ThisRef";
+    PagNodeKind[PagNodeKind["Function"] = 5] = "Function";
+    PagNodeKind[PagNodeKind["GlobalThis"] = 6] = "GlobalThis";
+})(PagNodeKind = exports.PagNodeKind || (exports.PagNodeKind = {}));
+class PagNode extends BaseGraph_1.BaseNode {
+    constructor(id, cid = undefined, value, k, s) {
+        super(id, k);
+        this.cid = cid;
+        this.value = value;
+        this.stmt = s;
+        this.pointTo = new Set;
+    }
+    getBasePt() {
+        return this.basePt;
+    }
+    setBasePt(pt) {
+        this.basePt = pt;
+    }
+    getCid() {
+        if (this.cid == undefined) {
+            throw new Error('cid is undefine');
+        }
+        return this.cid;
+    }
+    setCid(cid) {
+        this.cid = cid;
+    }
+    setStmt(s) {
+        this.stmt = s;
+    }
+    getStmt() {
+        return this.stmt;
+    }
+    hasOutgoingCopyEdge() {
+        return (this.copyOutEdges.size !== 0);
+    }
+    getOutgoingCopyEdges() {
+        return this.copyOutEdges;
+    }
+    getIncomingCopyEdges() {
+        return this.copyInEdges;
+    }
+    getOutgoingLoadEdges() {
+        return this.loadOutEdges;
+    }
+    getOutgoingWriteEdges() {
+        return this.writeOutEdges;
+    }
+    getIncomingWriteEdges() {
+        return this.writeInEdges;
+    }
+    getOutgoingThisEdges() {
+        return this.thisOutEdges;
+    }
+    getIncomingThisEdges() {
+        return this.thisInEdges;
+    }
+    addAddressInEdge(e) {
+        this.addressInEdges == undefined ? this.addressInEdges = new Set() : undefined;
+        this.addressInEdges.add(e);
+        this.addIncomingEdge(e);
+    }
+    addAddressOutEdge(e) {
+        this.addressOutEdges == undefined ? this.addressOutEdges = new Set() : undefined;
+        this.addressOutEdges.add(e);
+        this.addOutgoingEdge(e);
+    }
+    addCopyInEdge(e) {
+        this.copyInEdges == undefined ? this.copyInEdges = new Set() : undefined;
+        this.copyInEdges.add(e);
+        this.addIncomingEdge(e);
+    }
+    addCopyOutEdge(e) {
+        this.copyOutEdges == undefined ? this.copyOutEdges = new Set() : undefined;
+        this.copyOutEdges.add(e);
+        this.addOutgoingEdge(e);
+    }
+    addLoadInEdge(e) {
+        this.loadInEdges == undefined ? this.loadInEdges = new Set() : undefined;
+        this.loadInEdges.add(e);
+        this.addIncomingEdge(e);
+    }
+    addLoadOutEdge(e) {
+        this.loadOutEdges == undefined ? this.loadOutEdges = new Set() : undefined;
+        this.loadOutEdges.add(e);
+        this.addOutgoingEdge(e);
+    }
+    addWriteInEdge(e) {
+        var _a;
+        this.writeInEdges = (_a = this.writeInEdges) !== null && _a !== void 0 ? _a : new Set();
+        this.writeInEdges.add(e);
+        this.addIncomingEdge(e);
+    }
+    addWriteOutEdge(e) {
+        var _a;
+        this.writeOutEdges = (_a = this.writeOutEdges) !== null && _a !== void 0 ? _a : new Set();
+        this.writeOutEdges.add(e);
+        this.addOutgoingEdge(e);
+    }
+    addThisInEdge(e) {
+        var _a;
+        this.thisInEdges = (_a = this.thisInEdges) !== null && _a !== void 0 ? _a : new Set();
+        this.thisInEdges.add(e);
+        this.addIncomingEdge(e);
+    }
+    addThisOutEdge(e) {
+        var _a;
+        this.thisOutEdges = (_a = this.thisOutEdges) !== null && _a !== void 0 ? _a : new Set();
+        this.thisOutEdges.add(e);
+        this.addOutgoingEdge(e);
+    }
+    getValue() {
+        return this.value;
+    }
+    getPointTo() {
+        return this.pointTo;
+    }
+    addPointToElement(node) {
+        this.pointTo.add(node);
+    }
+    setPointTo(pts) {
+        this.pointTo = pts;
+    }
+    getOutEdges() {
+        return {
+            AddressEdge: this.addressOutEdges,
+            CopyEdge: this.copyOutEdges,
+            LoadEdge: this.loadOutEdges,
+            WriteEdge: this.writeOutEdges
+        };
+    }
+    getClonedFrom() {
+        return this.clonedFrom;
+    }
+    setClonedFrom(id) {
+        this.clonedFrom = id;
+    }
+    getDotAttr() {
+        switch (this.getKind()) {
+            case PagNodeKind.HeapObj:
+            case PagNodeKind.Function:
+            case PagNodeKind.GlobalThis:
+                return 'shape=box3d';
+            case PagNodeKind.LocalVar:
+                return 'shape=box';
+            case PagNodeKind.RefVar:
+                return 'shape=component';
+            case PagNodeKind.Param:
+                return 'shape=box';
+            default:
+                return 'shape=box';
+        }
+    }
+    getDotLabel() {
+        var _a;
+        let label;
+        let param;
+        label = PagNodeKind[this.getKind()];
+        label = label + ` ID: ${this.getID()} Ctx: ${this.cid}`;
+        if (this.basePt) {
+            label = label + ` base:{${this.basePt}}`;
+        }
+        label = label + ` pts:{${Array.from(this.pointTo).join(',')}}`;
+        if (this.getKind() == PagNodeKind.Param) {
+            param = this.value;
+            label = label + `\nParam#${param.getIndex()} ${param.toString()}`;
+        }
+        if (this.getKind() == PagNodeKind.ThisRef) {
+            label = label + `\n${this.value.toString()}`;
+        }
+        if (this.stmt) {
+            label = label + `\n${this.stmt.toString()}`;
+            let method = (_a = this.stmt.getCfg()) === null || _a === void 0 ? void 0 : _a.getDeclaringMethod().getSubSignature().toString();
+            if (method) {
+                label = label + '\n' + method;
+            }
+            label = label + ' ln: ' + this.stmt.getOriginPositionInfo().getLineNo();
+        }
+        return label;
+    }
+}
+exports.PagNode = PagNode;
+class PagLocalNode extends PagNode {
+    constructor(id, cid = undefined, value, stmt) {
+        super(id, cid, value, PagNodeKind.LocalVar, stmt);
+    }
+    addRelatedDynCallSite(cs) {
+        var _a;
+        this.relatedDynamicCallSite = (_a = this.relatedDynamicCallSite) !== null && _a !== void 0 ? _a : new Set();
+        this.relatedDynamicCallSite.add(cs);
+    }
+    getRelatedDynCallSites() {
+        return this.relatedDynamicCallSite;
+    }
+}
+exports.PagLocalNode = PagLocalNode;
+class PagInstanceFieldNode extends PagNode {
+    constructor(id, cid = undefined, instanceFieldRef, stmt) {
+        super(id, cid, instanceFieldRef, PagNodeKind.RefVar, stmt);
+    }
+}
+exports.PagInstanceFieldNode = PagInstanceFieldNode;
+class PagStaticFieldNode extends PagNode {
+    constructor(id, cid = undefined, staticFieldRef, stmt) {
+        super(id, cid, staticFieldRef, PagNodeKind.RefVar, stmt);
+    }
+}
+exports.PagStaticFieldNode = PagStaticFieldNode;
+class PagThisRefNode extends PagNode {
+    constructor(id, thisRef) {
+        super(id, DUMMY_PAG_NODE_ID, thisRef, PagNodeKind.ThisRef);
+        this.pointToNode = [];
+    }
+    getThisPTNode() {
+        return this.pointToNode;
+    }
+    addPTNode(ptNode) {
+        this.pointToNode.push(ptNode);
+    }
+}
+exports.PagThisRefNode = PagThisRefNode;
+class PagArrayNode extends PagNode {
+    constructor(id, cid = undefined, expr, stmt) {
+        super(id, cid, expr, PagNodeKind.LocalVar, stmt);
+        this.base = expr.getBase();
+    }
+}
+exports.PagArrayNode = PagArrayNode;
+/**
+ * below is heapObj like Node
+ */
+class PagNewExprNode extends PagNode {
+    constructor(id, cid = undefined, expr, stmt) {
+        super(id, cid, expr, PagNodeKind.HeapObj, stmt);
+    }
+    addFieldNode(fieldSignature, nodeID) {
+        if (!this.fieldNodes) {
+            this.fieldNodes = new Map();
+        }
+        if (this.fieldNodes.has(fieldSignature.getFieldSignature().toString())) {
+            return false;
+        }
+        this.fieldNodes.set(fieldSignature.getFieldSignature().toString(), nodeID);
+        return true;
+    }
+    getFieldNode(fieldSignature) {
+        if (!this.fieldNodes) {
+            return undefined;
+        }
+        return this.fieldNodes.get(fieldSignature.getFieldSignature().toString());
+    }
+    getFieldNodes() {
+        if (!this.fieldNodes) {
+            return undefined;
+        }
+        return this.fieldNodes;
+    }
+}
+exports.PagNewExprNode = PagNewExprNode;
+class PagNewArrayExprNode extends PagNode {
+    constructor(id, cid = undefined, expr, stmt) {
+        super(id, cid, expr, PagNodeKind.HeapObj, stmt);
+    }
+    addElementNode(nodeID) {
+        if (!this.elementNode) {
+            this.elementNode = nodeID;
+        }
+        return true;
+    }
+    getElementNode() {
+        return this.elementNode;
+    }
+}
+exports.PagNewArrayExprNode = PagNewArrayExprNode;
+class PagParamNode extends PagNode {
+    constructor(id, cid = undefined, r, stmt) {
+        super(id, cid, r, PagNodeKind.Param, stmt);
+    }
+}
+exports.PagParamNode = PagParamNode;
+class PagFuncNode extends PagNode {
+    // TODO: may add obj interface
+    constructor(id, cid = undefined, r, stmt) {
+        super(id, cid, r, PagNodeKind.Function, stmt);
+    }
+    setMethod(method) {
+        this.methodSignature = method;
+    }
+    getMethod() {
+        return this.methodSignature;
+    }
+}
+exports.PagFuncNode = PagFuncNode;
+/**
+ * almost same as PagNewExprNode, used only for globalThis and its field reference
+ */
+class PagGlobalThisNode extends PagNode {
+    constructor(id, cid = undefined, r, stmt) {
+        super(id, cid, r, PagNodeKind.GlobalThis, stmt);
+        this.fieldNodes = new Map();
+    }
+    addFieldNode(fieldSignature, nodeID) {
+        if (this.fieldNodes.has(fieldSignature.getFieldSignature().toString())) {
+            return false;
+        }
+        this.fieldNodes.set(fieldSignature.getFieldSignature().toString(), nodeID);
+        return true;
+    }
+    getFieldNode(fieldSignature) {
+        return this.fieldNodes.get(fieldSignature.getFieldSignature().toString());
+    }
+    getFieldNodes() {
+        return this.fieldNodes;
+    }
+}
+exports.PagGlobalThisNode = PagGlobalThisNode;
+class Pag extends BaseGraph_1.BaseGraph {
+    constructor() {
+        super(...arguments);
+        this.contextValueToIdMap = new Map();
+        // contextBaseToIdMap will only be used in instance field
+        // Value: instance field base value, NodeID: abstract nodes
+        this.contextBaseToIdMap = new Map();
+        // for reanalyze, will return new addr edges
+        this.stashAddrEdge = new Set();
+        this.addrEdge = new Set();
+        this.clonedNodeMap = new Map();
+    }
+    getCG() {
+        return this.cg;
+    }
+    /*
+     * Clone a PagNode with same cid/value/stmt,
+     * but different Node ID
+     */
+    getOrClonePagNode(src, basePt) {
+        if (src.getBasePt() != undefined) {
+            throw new Error('This is a cloned ref node, can not be cloned again');
+        }
+        let cloneSet = this.clonedNodeMap.get(src.getID());
+        if (!cloneSet) {
+            cloneSet = new Map();
+            this.clonedNodeMap.set(src.getID(), cloneSet);
+        }
+        else {
+            let nodeID = cloneSet.get(basePt);
+            if (nodeID) {
+                return this.getNode(nodeID);
+            }
+        }
+        // Not found
+        let cloneNode = this.addPagNode(src.getCid(), src.getValue(), src.getStmt(), false);
+        cloneNode.setClonedFrom(src.getID());
+        cloneSet.set(basePt, cloneNode.getID());
+        return cloneNode;
+    }
+    getOrClonePagFieldNode(src, basePt) {
+        let baseNode = this.getNode(basePt);
+        if (baseNode instanceof PagNewExprNode || baseNode instanceof PagGlobalThisNode) {
+            // check if real field node has been created with basePT, using FieldSignature as key
+            let existedNode = baseNode.getFieldNode(src.getValue());
+            if (existedNode) {
+                return this.getNode(existedNode);
+            }
+            let fieldNode = this.getOrClonePagNode(src, basePt);
+            baseNode.addFieldNode(src.getValue(), fieldNode.getID());
+            fieldNode.setBasePt(basePt);
+            return fieldNode;
+        }
+        else {
+            logger.error(`Error clone field node ${src.getValue()}`);
+            return undefined;
+        }
+    }
+    getOrClonePagArrayFieldNode(src, basePt) {
+        let baseNode = this.getNode(basePt);
+        if (baseNode instanceof PagNewArrayExprNode) {
+            // check if Array Ref real node has been created or not, if not: create a real Array Ref node
+            let existedNode = baseNode.getElementNode();
+            if (existedNode) {
+                return this.getNode(existedNode);
+            }
+            // let arrayBase: Local = (src.getValue() as ArkArrayRef).getBase()
+            let fieldNode = this.getOrClonePagNode(src, basePt);
+            baseNode.addElementNode(fieldNode.getID());
+            fieldNode.setBasePt(basePt);
+            return fieldNode;
+        }
+        else {
+            throw new Error(`Error clone array field node ${src.getValue()}`);
+        }
+    }
+    addPagNode(cid, value, stmt, refresh = true) {
+        let id = this.nodeNum;
+        let pagNode;
+        if (value instanceof Local_1.Local) {
+            const valueType = value.getType();
+            if (valueType instanceof Type_1.FunctionType &&
+                (value.getDeclaringStmt() === null)) {
+                // init function pointer
+                pagNode = new PagFuncNode(id, cid, value, stmt);
+                if (pagNode instanceof PagFuncNode) {
+                    pagNode.setMethod(valueType.getMethodSignature());
+                }
+            }
+            else {
+                // judge 'globalThis' is a redefined Local or real globalThis with its declaring stmt
+                // value has been replaced in param
+                if (value.getName() == exports.GLOBAL_THIS && value.getDeclaringStmt() == null) {
+                    pagNode = new PagGlobalThisNode(id, 0, value);
+                }
+                else {
+                    pagNode = new PagLocalNode(id, cid, value, stmt);
+                }
+            }
+        }
+        else if (value instanceof Ref_1.ArkInstanceFieldRef) {
+            pagNode = new PagInstanceFieldNode(id, cid, value, stmt);
+        }
+        else if (value instanceof Ref_1.ArkStaticFieldRef) {
+            pagNode = new PagStaticFieldNode(id, cid, value, stmt);
+        }
+        else if (value instanceof Ref_1.ArkArrayRef) {
+            pagNode = new PagArrayNode(id, cid, value, stmt);
+        }
+        else if (value instanceof Expr_1.ArkNewExpr) {
+            pagNode = new PagNewExprNode(id, cid, value, stmt);
+        }
+        else if (value instanceof Expr_1.ArkNewArrayExpr) {
+            pagNode = new PagNewArrayExprNode(id, cid, value, stmt);
+        }
+        else if (value instanceof Ref_1.ArkParameterRef) {
+            pagNode = new PagParamNode(id, cid, value, stmt);
+        }
+        else if (value instanceof Ref_1.ArkThisRef) {
+            throw new Error('This Node need use addThisNode method');
+        }
+        else {
+            throw new Error('unsupported Value type ' + value.getType().toString());
+        }
+        this.addNode(pagNode);
+        this.addContextMap(refresh, cid, id, value, stmt, pagNode);
+        return pagNode;
+    }
+    addContextMap(refresh, cid, id, value, stmt, pagNode) {
+        var _a;
+        if (!refresh) {
+            return;
+        }
+        let ctx2NdMap = this.contextValueToIdMap.get(value);
+        if (!ctx2NdMap) {
+            ctx2NdMap = new Map();
+            this.contextValueToIdMap.set(value, ctx2NdMap);
+        }
+        ctx2NdMap.set(cid, id);
+        if (value instanceof Ref_1.ArkInstanceFieldRef || value instanceof Ref_1.ArkArrayRef) {
+            let base = value.getBase();
+            //TODO: remove below once this Local is not uniq in @instance_init is fix
+            if (base instanceof Local_1.Local && base.getName() === 'this') {
+                (_a = stmt === null || stmt === void 0 ? void 0 : stmt.getCfg()) === null || _a === void 0 ? void 0 : _a.getStmts().forEach(s => {
+                    if (s instanceof Stmt_1.ArkAssignStmt &&
+                        (s.getLeftOp()) instanceof Local_1.Local &&
+                        s.getLeftOp().getName() === 'this') {
+                        base = s.getLeftOp();
+                        return;
+                    }
+                });
+            }
+            let ctxMap = this.contextBaseToIdMap.get(base);
+            if (ctxMap === undefined) {
+                ctxMap = new Map();
+                ctxMap.set(cid, [pagNode.getID()]);
+            }
+            else {
+                let nodes = ctxMap.get(cid);
+                if (nodes === undefined) {
+                    nodes = [pagNode.getID()];
+                }
+                else {
+                    nodes.push(pagNode.getID());
+                }
+                ctxMap.set(cid, nodes);
+            }
+            this.contextBaseToIdMap.set(base, ctxMap);
+        }
+    }
+    /*
+     * This node has no context info
+     * but point to node info
+     */
+    addPagThisRefNode(value) {
+        let id = this.nodeNum;
+        let pagNode = new PagThisRefNode(id, value);
+        this.addNode(pagNode);
+        return pagNode;
+    }
+    addPagThisLocalNode(ptNode, value) {
+        let id = this.nodeNum;
+        let pagNode = new PagLocalNode(id, ptNode, value);
+        this.addNode(pagNode);
+        return pagNode;
+    }
+    getOrNewThisRefNode(thisRefNodeID, value) {
+        if (thisRefNodeID != -1) {
+            return this.getNode(thisRefNodeID);
+        }
+        let thisRefNode = this.addPagThisRefNode(value);
+        return thisRefNode;
+    }
+    getOrNewThisLocalNode(cid, ptNode, value, s) {
+        if (ptNode != -1) {
+            return this.getNode(ptNode);
+        }
+        else {
+            return this.getOrNewNode(cid, value, s);
+        }
+    }
+    hasCtxNode(cid, v) {
+        let ctx2nd = this.contextValueToIdMap.get(v);
+        if (!ctx2nd) {
+            return undefined;
+        }
+        let ndId = ctx2nd.get(cid);
+        if (!ndId) {
+            return undefined;
+        }
+        return ndId;
+    }
+    hasCtxRetNode(cid, v) {
+        let ctx2nd = this.contextValueToIdMap.get(v);
+        if (!ctx2nd) {
+            return undefined;
+        }
+        let ndId = ctx2nd.get(cid);
+        if (!ndId) {
+            return undefined;
+        }
+        return ndId;
+    }
+    getOrNewNode(cid, v, s) {
+        let nodeId = this.hasCtxNode(cid, v);
+        if (nodeId != undefined) {
+            return this.getNode(nodeId);
+        }
+        return this.addPagNode(cid, v, s);
+    }
+    getNodesByValue(v) {
+        return this.contextValueToIdMap.get(v);
+    }
+    getNodesByBaseValue(v) {
+        return this.contextBaseToIdMap.get(v);
+    }
+    addPagEdge(src, dst, kind, stmt) {
+        // TODO: check if the edge already existing
+        let edge = new PagEdge(src, dst, kind, stmt);
+        if (this.ifEdgeExisting(edge)) {
+            return false;
+        }
+        //src.addOutgoingEdge(edge);
+        //dst.addIncomingEdge(edge);
+        switch (kind) {
+            case PagEdgeKind.Copy:
+                src.addCopyOutEdge(edge);
+                dst.addCopyInEdge(edge);
+                break;
+            case PagEdgeKind.Address:
+                src.addAddressOutEdge(edge);
+                dst.addAddressInEdge(edge);
+                this.addrEdge.add(edge);
+                this.stashAddrEdge.add(edge);
+                break;
+            case PagEdgeKind.Write:
+                src.addWriteOutEdge(edge);
+                dst.addWriteInEdge(edge);
+                break;
+            case PagEdgeKind.Load:
+                src.addLoadOutEdge(edge);
+                dst.addLoadInEdge(edge);
+                break;
+            case PagEdgeKind.This:
+                src.addThisOutEdge(edge);
+                dst.addThisInEdge(edge);
+            default:
+                ;
+        }
+        return true;
+    }
+    getAddrEdges() {
+        return this.stashAddrEdge;
+    }
+    resetAddrEdges() {
+        this.stashAddrEdge.clear();
+    }
+    getGraphName() {
+        return 'PAG';
+    }
+    dump(name) {
+        let printer = new GraphPrinter_1.GraphPrinter(this);
+        PrinterBuilder_1.PrinterBuilder.dump(printer, name);
+    }
+}
+exports.Pag = Pag;
+class FuncPag {
+    getInternalEdges() {
+        return this.internalEdges;
+    }
+    addNormalCallSite(cs) {
+        var _a;
+        this.normalCallSites = (_a = this.normalCallSites) !== null && _a !== void 0 ? _a : new Set();
+        this.normalCallSites.add(cs);
+    }
+    getNormalCallSites() {
+        var _a;
+        this.normalCallSites = (_a = this.normalCallSites) !== null && _a !== void 0 ? _a : new Set();
+        return this.normalCallSites;
+    }
+    addDynamicCallSite(cs) {
+        var _a;
+        this.dynamicCallSites = (_a = this.dynamicCallSites) !== null && _a !== void 0 ? _a : new Set();
+        this.dynamicCallSites.add(cs);
+    }
+    getDynamicCallSites() {
+        var _a;
+        this.dynamicCallSites = (_a = this.dynamicCallSites) !== null && _a !== void 0 ? _a : new Set();
+        return this.dynamicCallSites;
+    }
+    addInternalEdge(stmt, k) {
+        this.internalEdges == undefined ? this.internalEdges = new Set() : undefined;
+        let lhOp = stmt.getLeftOp();
+        let rhOp = stmt.getRightOp();
+        if (rhOp instanceof Constant_1.Constant) {
+            return false;
+        }
+        let iEdge = { src: rhOp, dst: lhOp, kind: k, stmt: stmt };
+        this.internalEdges.add(iEdge);
+        return true;
+    }
+}
+exports.FuncPag = FuncPag;