arkanalyzer 1.0.20 → 1.0.21

package/lib/core/graph/DependsGraph.js

@@ -1,87 +1,87 @@
-"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.DependsGraph = exports.DependsEdge = exports.DependsNode = void 0;
-const BaseExplicitGraph_1 = require("./BaseExplicitGraph");
-class DependsNode extends BaseExplicitGraph_1.BaseNode {
-    constructor(id, attr) {
-        super(id, attr.kind);
-        this.attr = attr;
-    }
-    getNodeAttr() {
-        return this.attr;
-    }
-    setNodeAttr(attr) {
-        this.attr = attr;
-    }
-    getDotLabel() {
-        return this.attr.name;
-    }
-}
-exports.DependsNode = DependsNode;
-class DependsEdge extends BaseExplicitGraph_1.BaseEdge {
-    constructor(s, d, attr) {
-        super(s, d, attr.kind);
-        this.attr = attr;
-    }
-    getEdgeAttr() {
-        return this.attr;
-    }
-    setEdgeAttr(attr) {
-        this.attr = attr;
-    }
-    getKey() {
-        return `${this.getSrcID()}-${this.getDstID()}-${this.getKind()}`;
-    }
-}
-exports.DependsEdge = DependsEdge;
-class DependsGraph extends BaseExplicitGraph_1.BaseExplicitGraph {
-    constructor() {
-        super();
-        this.depsMap = new Map();
-        this.edgesMap = new Map();
-    }
-    hasDepsNode(key) {
-        return this.depsMap.has(key);
-    }
-    addDepsNode(key, attr) {
-        if (this.depsMap.has(key)) {
-            // update attr
-            let node = this.getNode(this.depsMap.get(key));
-            node.setNodeAttr(attr);
-            return node;
-        }
-        let node = new DependsNode(this.getNodeNum(), attr);
-        this.depsMap.set(key, node.getID());
-        this.addNode(node);
-        return node;
-    }
-    addEdge(src, dst, attr) {
-        let edge = new DependsEdge(src, dst, attr);
-        let key = edge.getKey();
-        if (this.edgesMap.has(key)) {
-            return this.edgesMap.get(key);
-        }
-        this.edgesMap.set(key, edge);
-        src.addOutgoingEdge(edge);
-        dst.addIncomingEdge(edge);
-        return edge;
-    }
-    getGraphName() {
-        return 'DependsGraph';
-    }
-}
-exports.DependsGraph = DependsGraph;
+"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.DependsGraph = exports.DependsEdge = exports.DependsNode = void 0;
+const BaseExplicitGraph_1 = require("./BaseExplicitGraph");
+class DependsNode extends BaseExplicitGraph_1.BaseNode {
+    constructor(id, attr) {
+        super(id, attr.kind);
+        this.attr = attr;
+    }
+    getNodeAttr() {
+        return this.attr;
+    }
+    setNodeAttr(attr) {
+        this.attr = attr;
+    }
+    getDotLabel() {
+        return this.attr.name;
+    }
+}
+exports.DependsNode = DependsNode;
+class DependsEdge extends BaseExplicitGraph_1.BaseEdge {
+    constructor(s, d, attr) {
+        super(s, d, attr.kind);
+        this.attr = attr;
+    }
+    getEdgeAttr() {
+        return this.attr;
+    }
+    setEdgeAttr(attr) {
+        this.attr = attr;
+    }
+    getKey() {
+        return `${this.getSrcID()}-${this.getDstID()}-${this.getKind()}`;
+    }
+}
+exports.DependsEdge = DependsEdge;
+class DependsGraph extends BaseExplicitGraph_1.BaseExplicitGraph {
+    constructor() {
+        super();
+        this.depsMap = new Map();
+        this.edgesMap = new Map();
+    }
+    hasDepsNode(key) {
+        return this.depsMap.has(key);
+    }
+    addDepsNode(key, attr) {
+        if (this.depsMap.has(key)) {
+            // update attr
+            let node = this.getNode(this.depsMap.get(key));
+            node.setNodeAttr(attr);
+            return node;
+        }
+        let node = new DependsNode(this.getNodeNum(), attr);
+        this.depsMap.set(key, node.getID());
+        this.addNode(node);
+        return node;
+    }
+    addEdge(src, dst, attr) {
+        let edge = new DependsEdge(src, dst, attr);
+        let key = edge.getKey();
+        if (this.edgesMap.has(key)) {
+            return this.edgesMap.get(key);
+        }
+        this.edgesMap.set(key, edge);
+        src.addOutgoingEdge(edge);
+        dst.addIncomingEdge(edge);
+        return edge;
+    }
+    getGraphName() {
+        return 'DependsGraph';
+    }
+}
+exports.DependsGraph = DependsGraph;

package/lib/core/graph/DominanceFinder.d.ts

@@ -1,16 +1,16 @@
-import { BasicBlock } from './BasicBlock';
-import { Cfg } from './Cfg';
-export declare class DominanceFinder {
-    private blocks;
-    private blockToIdx;
-    private idoms;
-    private domFrontiers;
-    constructor(cfg: Cfg);
-    getDominanceFrontiers(block: BasicBlock): Set<BasicBlock>;
-    getBlocks(): BasicBlock[];
-    getBlockToIdx(): Map<BasicBlock, number>;
-    getImmediateDominators(): number[];
-    private getFirstDefinedBlockPredIdx;
-    private intersect;
-}
+import { BasicBlock } from './BasicBlock';
+import { Cfg } from './Cfg';
+export declare class DominanceFinder {
+    private blocks;
+    private blockToIdx;
+    private idoms;
+    private domFrontiers;
+    constructor(cfg: Cfg);
+    getDominanceFrontiers(block: BasicBlock): Set<BasicBlock>;
+    getBlocks(): BasicBlock[];
+    getBlockToIdx(): Map<BasicBlock, number>;
+    getImmediateDominators(): number[];
+    private getFirstDefinedBlockPredIdx;
+    private intersect;
+}
 //# sourceMappingURL=DominanceFinder.d.ts.map

package/lib/core/graph/DominanceFinder.js

@@ -1,121 +1,121 @@
-"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.DominanceFinder = void 0;
-class DominanceFinder {
-    constructor(cfg) {
-        this.blocks = [];
-        this.blockToIdx = new Map;
-        this.idoms = [];
-        this.domFrontiers = [];
-        this.blocks = Array.from(cfg.getBlocks());
-        for (let i = 0; i < this.blocks.length; i++) {
-            let block = this.blocks[i];
-            this.blockToIdx.set(block, i);
-        }
-        const startingBlock = cfg.getStartingBlock();
-        // calculate immediate dominator for each block
-        this.idoms = new Array(this.blocks.length);
-        this.idoms[0] = 0;
-        for (let i = 1; i < this.idoms.length; i++) {
-            this.idoms[i] = -1;
-        }
-        let isChanged = true;
-        while (isChanged) {
-            isChanged = false;
-            for (const block of this.blocks) {
-                if (block === startingBlock) {
-                    continue;
-                }
-                let blockIdx = this.blockToIdx.get(block);
-                let preds = Array.from(block.getPredecessors());
-                let newIdom = this.getFirstDefinedBlockPredIdx(preds);
-                if (preds.length > 0 && newIdom !== -1) {
-                    for (const pred of preds) {
-                        let predIdx = this.blockToIdx.get(pred);
-                        if (this.idoms[predIdx] !== -1) {
-                            newIdom = this.intersect(newIdom, predIdx);
-                        }
-                    }
-                    if (this.idoms[blockIdx] !== newIdom) {
-                        this.idoms[blockIdx] = newIdom;
-                        isChanged = true;
-                    }
-                }
-            }
-        }
-        // calculate dominance frontiers for each block
-        this.domFrontiers = new Array(this.blocks.length);
-        for (let i = 0; i < this.domFrontiers.length; i++) {
-            this.domFrontiers[i] = new Array();
-        }
-        for (const block of this.blocks) {
-            let preds = Array.from(block.getPredecessors());
-            if (preds.length > 1) {
-                let blockIdx = this.blockToIdx.get(block);
-                for (const pred of preds) {
-                    let predIdx = this.blockToIdx.get(pred);
-                    while (predIdx !== this.idoms[blockIdx]) {
-                        this.domFrontiers[predIdx].push(blockIdx);
-                        predIdx = this.idoms[predIdx];
-                    }
-                }
-            }
-        }
-    }
-    getDominanceFrontiers(block) {
-        if (!this.blockToIdx.has(block)) {
-            throw new Error("The given block: " + block + " is not in Cfg!");
-        }
-        let idx = this.blockToIdx.get(block);
-        let dfs = new Set();
-        let dfsIdx = this.domFrontiers[idx];
-        for (const dfIdx of dfsIdx) {
-            dfs.add(this.blocks[dfIdx]);
-        }
-        return dfs;
-    }
-    getBlocks() {
-        return this.blocks;
-    }
-    getBlockToIdx() {
-        return this.blockToIdx;
-    }
-    getImmediateDominators() {
-        return this.idoms;
-    }
-    getFirstDefinedBlockPredIdx(preds) {
-        for (const block of preds) {
-            let idx = this.blockToIdx.get(block);
-            if (this.idoms[idx] !== -1) {
-                return idx;
-            }
-        }
-        return -1;
-    }
-    intersect(a, b) {
-        while (a !== b) {
-            if (a > b) {
-                a = this.idoms[a];
-            }
-            else {
-                b = this.idoms[b];
-            }
-        }
-        return a;
-    }
-}
-exports.DominanceFinder = DominanceFinder;
+"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.DominanceFinder = void 0;
+class DominanceFinder {
+    constructor(cfg) {
+        this.blocks = [];
+        this.blockToIdx = new Map;
+        this.idoms = [];
+        this.domFrontiers = [];
+        this.blocks = Array.from(cfg.getBlocks());
+        for (let i = 0; i < this.blocks.length; i++) {
+            let block = this.blocks[i];
+            this.blockToIdx.set(block, i);
+        }
+        const startingBlock = cfg.getStartingBlock();
+        // calculate immediate dominator for each block
+        this.idoms = new Array(this.blocks.length);
+        this.idoms[0] = 0;
+        for (let i = 1; i < this.idoms.length; i++) {
+            this.idoms[i] = -1;
+        }
+        let isChanged = true;
+        while (isChanged) {
+            isChanged = false;
+            for (const block of this.blocks) {
+                if (block === startingBlock) {
+                    continue;
+                }
+                let blockIdx = this.blockToIdx.get(block);
+                let preds = Array.from(block.getPredecessors());
+                let newIdom = this.getFirstDefinedBlockPredIdx(preds);
+                if (preds.length > 0 && newIdom !== -1) {
+                    for (const pred of preds) {
+                        let predIdx = this.blockToIdx.get(pred);
+                        if (this.idoms[predIdx] !== -1) {
+                            newIdom = this.intersect(newIdom, predIdx);
+                        }
+                    }
+                    if (this.idoms[blockIdx] !== newIdom) {
+                        this.idoms[blockIdx] = newIdom;
+                        isChanged = true;
+                    }
+                }
+            }
+        }
+        // calculate dominance frontiers for each block
+        this.domFrontiers = new Array(this.blocks.length);
+        for (let i = 0; i < this.domFrontiers.length; i++) {
+            this.domFrontiers[i] = new Array();
+        }
+        for (const block of this.blocks) {
+            let preds = Array.from(block.getPredecessors());
+            if (preds.length > 1) {
+                let blockIdx = this.blockToIdx.get(block);
+                for (const pred of preds) {
+                    let predIdx = this.blockToIdx.get(pred);
+                    while (predIdx !== this.idoms[blockIdx]) {
+                        this.domFrontiers[predIdx].push(blockIdx);
+                        predIdx = this.idoms[predIdx];
+                    }
+                }
+            }
+        }
+    }
+    getDominanceFrontiers(block) {
+        if (!this.blockToIdx.has(block)) {
+            throw new Error("The given block: " + block + " is not in Cfg!");
+        }
+        let idx = this.blockToIdx.get(block);
+        let dfs = new Set();
+        let dfsIdx = this.domFrontiers[idx];
+        for (const dfIdx of dfsIdx) {
+            dfs.add(this.blocks[dfIdx]);
+        }
+        return dfs;
+    }
+    getBlocks() {
+        return this.blocks;
+    }
+    getBlockToIdx() {
+        return this.blockToIdx;
+    }
+    getImmediateDominators() {
+        return this.idoms;
+    }
+    getFirstDefinedBlockPredIdx(preds) {
+        for (const block of preds) {
+            let idx = this.blockToIdx.get(block);
+            if (this.idoms[idx] !== -1) {
+                return idx;
+            }
+        }
+        return -1;
+    }
+    intersect(a, b) {
+        while (a !== b) {
+            if (a > b) {
+                a = this.idoms[a];
+            }
+            else {
+                b = this.idoms[b];
+            }
+        }
+        return a;
+    }
+}
+exports.DominanceFinder = DominanceFinder;

package/lib/core/graph/DominanceTree.d.ts

@@ -1,13 +1,13 @@
-import { BasicBlock } from './BasicBlock';
-import { DominanceFinder } from './DominanceFinder';
-export declare class DominanceTree {
-    private blocks;
-    private blockToIdx;
-    private children;
-    private parents;
-    constructor(dominanceFinder: DominanceFinder);
-    getAllNodesDFS(): BasicBlock[];
-    getChildren(block: BasicBlock): BasicBlock[];
-    getRoot(): BasicBlock;
-}
+import { BasicBlock } from './BasicBlock';
+import { DominanceFinder } from './DominanceFinder';
+export declare class DominanceTree {
+    private blocks;
+    private blockToIdx;
+    private children;
+    private parents;
+    constructor(dominanceFinder: DominanceFinder);
+    getAllNodesDFS(): BasicBlock[];
+    getChildren(block: BasicBlock): BasicBlock[];
+    getRoot(): BasicBlock;
+}
 //# sourceMappingURL=DominanceTree.d.ts.map

package/lib/core/graph/DominanceTree.js

@@ -1,70 +1,70 @@
-"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.DominanceTree = void 0;
-class DominanceTree {
-    constructor(dominanceFinder) {
-        this.blocks = [];
-        this.blockToIdx = new Map();
-        this.children = [];
-        this.parents = [];
-        this.blocks = dominanceFinder.getBlocks();
-        this.blockToIdx = dominanceFinder.getBlockToIdx();
-        let idoms = dominanceFinder.getImmediateDominators();
-        // build the tree
-        let treeSize = this.blocks.length;
-        this.children = new Array(treeSize);
-        this.parents = new Array(treeSize);
-        for (let i = 0; i < treeSize; i++) {
-            this.children[i] = [];
-            this.parents[i] = -1;
-        }
-        for (let i = 0; i < treeSize; i++) {
-            if (idoms[i] !== i) {
-                this.parents[i] = idoms[i];
-                this.children[idoms[i]].push(i);
-            }
-        }
-    }
-    getAllNodesDFS() {
-        let dfsBlocks = new Array();
-        let queue = new Array();
-        queue.push(this.getRoot());
-        while (queue.length !== 0) {
-            let curr = queue.splice(0, 1)[0];
-            dfsBlocks.push(curr);
-            let childList = this.getChildren(curr);
-            if (childList.length !== 0) {
-                for (let i = childList.length - 1; i >= 0; i--) {
-                    queue.splice(0, 0, childList[i]);
-                }
-            }
-        }
-        return dfsBlocks;
-    }
-    getChildren(block) {
-        let childList = new Array();
-        let idx = this.blockToIdx.get(block);
-        for (const i of this.children[idx]) {
-            childList.push(this.blocks[i]);
-        }
-        return childList;
-    }
-    getRoot() {
-        return this.blocks[0];
-    }
-}
-exports.DominanceTree = DominanceTree;
+"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.DominanceTree = void 0;
+class DominanceTree {
+    constructor(dominanceFinder) {
+        this.blocks = [];
+        this.blockToIdx = new Map();
+        this.children = [];
+        this.parents = [];
+        this.blocks = dominanceFinder.getBlocks();
+        this.blockToIdx = dominanceFinder.getBlockToIdx();
+        let idoms = dominanceFinder.getImmediateDominators();
+        // build the tree
+        let treeSize = this.blocks.length;
+        this.children = new Array(treeSize);
+        this.parents = new Array(treeSize);
+        for (let i = 0; i < treeSize; i++) {
+            this.children[i] = [];
+            this.parents[i] = -1;
+        }
+        for (let i = 0; i < treeSize; i++) {
+            if (idoms[i] !== i) {
+                this.parents[i] = idoms[i];
+                this.children[idoms[i]].push(i);
+            }
+        }
+    }
+    getAllNodesDFS() {
+        let dfsBlocks = new Array();
+        let queue = new Array();
+        queue.push(this.getRoot());
+        while (queue.length !== 0) {
+            let curr = queue.splice(0, 1)[0];
+            dfsBlocks.push(curr);
+            let childList = this.getChildren(curr);
+            if (childList.length !== 0) {
+                for (let i = childList.length - 1; i >= 0; i--) {
+                    queue.splice(0, 0, childList[i]);
+                }
+            }
+        }
+        return dfsBlocks;
+    }
+    getChildren(block) {
+        let childList = new Array();
+        let idx = this.blockToIdx.get(block);
+        for (const i of this.children[idx]) {
+            childList.push(this.blocks[i]);
+        }
+        return childList;
+    }
+    getRoot() {
+        return this.blocks[0];
+    }
+}
+exports.DominanceTree = DominanceTree;

package/lib/core/graph/GraphTraits.d.ts

@@ -1,8 +1,8 @@
-export type NodeID = number;
-export type Kind = number;
-export interface GraphTraits<Node> {
-    nodesItor(): IterableIterator<Node>;
-    getGraphName(): string;
-    getNode(id: NodeID): Node | undefined;
-}
+export type NodeID = number;
+export type Kind = number;
+export interface GraphTraits<Node> {
+    nodesItor(): IterableIterator<Node>;
+    getGraphName(): string;
+    getNode(id: NodeID): Node | undefined;
+}
 //# sourceMappingURL=GraphTraits.d.ts.map

package/lib/core/graph/GraphTraits.js

@@ -1,16 +1,16 @@
-"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 });
+"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 });