arkanalyzer 1.0.85 → 1.0.87

package/lib/frontend/cppFrontend/graph/builder/LoopBuilder.js

@@ -0,0 +1,261 @@
+"use strict";
+/*
+ * Copyright (c) 2025 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.CxxLoopBuilder = void 0;
+const BasicBlock_1 = require("../../../../core/graph/BasicBlock");
+const Stmt_1 = require("../../../../core/base/Stmt");
+const Expr_1 = require("../../../../core/base/Expr");
+const Builtin_1 = require("../../common/Builtin");
+const CfgBuilder_1 = require("./CfgBuilder");
+const ArkIRTransformer_1 = require("../../../../core/common/ArkIRTransformer");
+const ArkIRTransformer_2 = require("../../common/ArkIRTransformer");
+/**
+ * Builder for loop in CFG
+ */
+class CxxLoopBuilder {
+    rebuildBlocksInLoop(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, blockBuilders) {
+        for (const blockBuilder of blocksContainLoopCondition) {
+            if (!blockBuilderToCfgBlock.get(blockBuilder)) {
+                continue;
+            }
+            const block = blockBuilderToCfgBlock.get(blockBuilder);
+            const blockId = block.getId();
+            const stmts = block.getStmts();
+            const stmtsCnt = stmts.length;
+            const { ifStmtIdx, iteratorNextStmtIdx, dummyInitializerStmtIdx } = this.findIteratorIdx(stmts);
+            if (iteratorNextStmtIdx !== -1 || dummyInitializerStmtIdx !== -1) {
+                const stmtsInsertBeforeCondition = stmts.slice(0, dummyInitializerStmtIdx);
+                // If the loop body is empty, the loop conditional block should contain its own
+                const emptyLoopBody = blockBuilder.nexts.length === 1;
+                if (emptyLoopBody) {
+                    blockBuilder.nexts.splice(0, 0, blockBuilder);
+                    blockBuilder.lasts.push(blockBuilder);
+                    block.getSuccessors().splice(0, 0, block);
+                    block.addPredecessorBlock(block);
+                }
+                let prevBlockBuilderContainsLoop = this.doesPrevBlockBuilderContainLoop(blockBuilder, blockId, blocksContainLoopCondition);
+                if (prevBlockBuilderContainsLoop) {
+                    // should create an extra block when previous block contains loop condition
+                    this.insertBeforeConditionBlockBuilder(blockBuilderToCfgBlock, blockBuilder, stmtsInsertBeforeCondition, false, basicBlockSet, blockBuilders);
+                }
+                else {
+                    const blockBuilderBeforeCondition = blockBuilder.lasts[0];
+                    const blockBeforeCondition = blockBuilderToCfgBlock.get(blockBuilderBeforeCondition);
+                    stmtsInsertBeforeCondition.forEach(stmt => blockBeforeCondition === null || blockBeforeCondition === void 0 ? void 0 : blockBeforeCondition.getStmts().push(stmt));
+                }
+                if (iteratorNextStmtIdx !== -1 && dummyInitializerStmtIdx !== -1) {
+                    // put statements which get value of iterator into block after condition
+                    const blockBuilderAfterCondition = blockBuilder.nexts[0];
+                    const blockAfterCondition = blockBuilderToCfgBlock.get(blockBuilderAfterCondition);
+                    const stmtsAfterCondition = stmts.slice(iteratorNextStmtIdx + 1);
+                    blockAfterCondition === null || blockAfterCondition === void 0 ? void 0 : blockAfterCondition.getStmts().splice(0, 0, ...stmtsAfterCondition);
+                    const iteratorStmts = stmts[iteratorNextStmtIdx];
+                    blockAfterCondition === null || blockAfterCondition === void 0 ? void 0 : blockAfterCondition.getStmts().push(iteratorStmts);
+                }
+                else if (dummyInitializerStmtIdx !== -1 && ifStmtIdx !== stmtsCnt - 1) {
+                    // put incrementor statements into block which reenters condition
+                    this.adjustIncrementorStmts(stmts, ifStmtIdx, blockBuilder, blockId, blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, emptyLoopBody, blockBuilders);
+                }
+                // remove statements which should not in condition
+                const firstStmtIdxInCondition = dummyInitializerStmtIdx + 1;
+                stmts.splice(0, firstStmtIdxInCondition);
+                stmts.splice(ifStmtIdx - firstStmtIdxInCondition + 1);
+            }
+        }
+    }
+    doesPrevBlockBuilderContainLoop(currBlockBuilder, currBlockId, blocksContainLoopCondition) {
+        let prevBlockBuilderContainsLoop = false;
+        for (const prevBlockBuilder of currBlockBuilder.lasts) {
+            if (prevBlockBuilder.id < currBlockId && blocksContainLoopCondition.has(prevBlockBuilder)) {
+                prevBlockBuilderContainsLoop = true;
+                break;
+            }
+        }
+        return prevBlockBuilderContainsLoop;
+    }
+    insertBeforeConditionBlockBuilder(blockBuilderToCfgBlock, conditionBlockBuilder, stmtsInsertBeforeCondition, collectReenter, basicBlockSet, blockBuilders) {
+        if (stmtsInsertBeforeCondition.length === 0) {
+            return;
+        }
+        const blockId = conditionBlockBuilder.id;
+        const block = this.getBlockFromMap(blockBuilderToCfgBlock, conditionBlockBuilder);
+        const { blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition, } = this.collectBlocksBeforeAndReenter(blockBuilderToCfgBlock, conditionBlockBuilder, blockId);
+        const { collectedBlockBuilders, collectedBlocks } = this.getCollectedBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition);
+        const { blockBuilderInsertBeforeCondition, blockInsertBeforeCondition } = this.createAndLinkBlocks(collectedBlockBuilders, collectedBlocks, conditionBlockBuilder, stmtsInsertBeforeCondition, block);
+        this.updatePredecessors(collectedBlockBuilders, blockBuilderToCfgBlock, conditionBlockBuilder, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition);
+        const { newPrevBlockBuildersBeforeCondition, newPrevBlocksBeforeCondition } = this.getNewPrevBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition);
+        this.updateConditionBlockBuilder(conditionBlockBuilder, newPrevBlockBuildersBeforeCondition, block, newPrevBlocksBeforeCondition);
+        this.finalizeInsertion(blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, basicBlockSet, blockBuilderToCfgBlock, blockBuilders);
+    }
+    getBlockFromMap(blockBuilderToCfgBlock, conditionBlockBuilder) {
+        return blockBuilderToCfgBlock.get(conditionBlockBuilder);
+    }
+    collectBlocksBeforeAndReenter(blockBuilderToCfgBlock, conditionBlockBuilder, blockId) {
+        const blockBuildersBeforeCondition = [];
+        const blocksBeforeCondition = [];
+        const blockBuildersReenterCondition = [];
+        const blocksReenterCondition = [];
+        for (const prevBlockBuilder of conditionBlockBuilder.lasts) {
+            const prevBlock = blockBuilderToCfgBlock.get(prevBlockBuilder);
+            if (prevBlock.getId() < blockId) {
+                blockBuildersBeforeCondition.push(prevBlockBuilder);
+                blocksBeforeCondition.push(prevBlock);
+            }
+            else {
+                blockBuildersReenterCondition.push(prevBlockBuilder);
+                blocksReenterCondition.push(prevBlock);
+            }
+        }
+        return {
+            blockBuildersBeforeCondition,
+            blocksBeforeCondition,
+            blockBuildersReenterCondition,
+            blocksReenterCondition,
+        };
+    }
+    getCollectedBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition) {
+        let collectedBlockBuilders = [];
+        let collectedBlocks = [];
+        if (collectReenter) {
+            collectedBlockBuilders = blockBuildersReenterCondition;
+            collectedBlocks = blocksReenterCondition;
+        }
+        else {
+            collectedBlockBuilders = blockBuildersBeforeCondition;
+            collectedBlocks = blocksBeforeCondition;
+        }
+        return { collectedBlockBuilders, collectedBlocks };
+    }
+    createAndLinkBlocks(collectedBlockBuilders, collectedBlocks, conditionBlockBuilder, stmtsInsertBeforeCondition, block) {
+        const blockBuilderInsertBeforeCondition = new CfgBuilder_1.BlockBuilder(-1, []);
+        blockBuilderInsertBeforeCondition.lasts.push(...collectedBlockBuilders);
+        blockBuilderInsertBeforeCondition.nexts.push(conditionBlockBuilder);
+        const blockInsertBeforeCondition = new BasicBlock_1.BasicBlock();
+        stmtsInsertBeforeCondition.forEach(stmt => blockInsertBeforeCondition.getStmts().push(stmt));
+        blockInsertBeforeCondition.getPredecessors().push(...collectedBlocks);
+        blockInsertBeforeCondition.addSuccessorBlock(block);
+        return { blockBuilderInsertBeforeCondition, blockInsertBeforeCondition };
+    }
+    updatePredecessors(collectedBlockBuilders, blockBuilderToCfgBlock, conditionBlockBuilder, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition) {
+        for (const prevBlockBuilder of collectedBlockBuilders) {
+            const prevBlock = blockBuilderToCfgBlock.get(prevBlockBuilder);
+            for (let j = 0; j < prevBlockBuilder.nexts.length; j++) {
+                if (prevBlockBuilder.nexts[j] === conditionBlockBuilder) {
+                    prevBlockBuilder.nexts[j] = blockBuilderInsertBeforeCondition;
+                    prevBlock.setSuccessorBlock(j, blockInsertBeforeCondition);
+                    break;
+                }
+            }
+        }
+    }
+    getNewPrevBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition) {
+        let newPrevBlockBuildersBeforeCondition = [];
+        let newPrevBlocksBeforeCondition = [];
+        if (collectReenter) {
+            newPrevBlockBuildersBeforeCondition = [...blockBuildersBeforeCondition, blockBuilderInsertBeforeCondition];
+            newPrevBlocksBeforeCondition = [...blocksBeforeCondition, blockInsertBeforeCondition];
+        }
+        else {
+            newPrevBlockBuildersBeforeCondition = [blockBuilderInsertBeforeCondition, ...blockBuildersReenterCondition];
+            newPrevBlocksBeforeCondition = [blockInsertBeforeCondition, ...blocksReenterCondition];
+        }
+        return {
+            newPrevBlockBuildersBeforeCondition,
+            newPrevBlocksBeforeCondition,
+        };
+    }
+    updateConditionBlockBuilder(conditionBlockBuilder, newPrevBlockBuildersBeforeCondition, block, newPrevBlocksBeforeCondition) {
+        conditionBlockBuilder.lasts = newPrevBlockBuildersBeforeCondition;
+        const predecessorsCnt = block.getPredecessors().length;
+        block.getPredecessors().splice(0, predecessorsCnt, ...newPrevBlocksBeforeCondition);
+    }
+    finalizeInsertion(blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, basicBlockSet, blockBuilderToCfgBlock, blockBuilders) {
+        blockBuilders.push(blockBuilderInsertBeforeCondition);
+        basicBlockSet.add(blockInsertBeforeCondition);
+        blockBuilderToCfgBlock.set(blockBuilderInsertBeforeCondition, blockInsertBeforeCondition);
+    }
+    findIteratorIdx(stmts) {
+        var _a;
+        let ifStmtIdx = -1;
+        let iteratorNextStmtIdx = -1;
+        let dummyInitializerStmtIdx = -1;
+        const stmtsCnt = stmts.length;
+        for (let i = 0; i < stmtsCnt; i++) {
+            const stmt = stmts[i];
+            if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getRightOp() instanceof Expr_1.ArkInstanceInvokeExpr) {
+                const invokeExpr = stmt.getRightOp();
+                if (invokeExpr.getMethodSignature().getMethodSubSignature().getMethodName() === Builtin_1.BuiltinCxx.ITERATOR_NEXT) {
+                    iteratorNextStmtIdx = i;
+                    continue;
+                }
+            }
+            if (stmt.toString() === ArkIRTransformer_1.ArkIRTransformer.DUMMY_LOOP_INITIALIZER_STMT) {
+                dummyInitializerStmtIdx = i;
+                continue;
+            }
+            if (stmt instanceof Stmt_1.ArkIfStmt) {
+                ifStmtIdx = i;
+            }
+            if (stmt instanceof ArkIRTransformer_1.DummyStmt && ((_a = stmt.toString()) === null || _a === void 0 ? void 0 : _a.startsWith(ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END))) {
+                ifStmtIdx = i;
+            }
+        }
+        return {
+            ifStmtIdx: ifStmtIdx,
+            iteratorNextStmtIdx: iteratorNextStmtIdx,
+            dummyInitializerStmtIdx: dummyInitializerStmtIdx,
+        };
+    }
+    adjustIncrementorStmts(stmts, ifStmtIdx, currBlockBuilder, currBlockId, blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, emptyLoopBody, blockBuilders) {
+        const stmtsReenterCondition = stmts.slice(ifStmtIdx + 1);
+        if (emptyLoopBody) {
+            const incrementorBlockBuilder = new CfgBuilder_1.BlockBuilder(-1, []);
+            incrementorBlockBuilder.lasts.push(currBlockBuilder);
+            currBlockBuilder.nexts[0] = incrementorBlockBuilder;
+            incrementorBlockBuilder.nexts.push(currBlockBuilder);
+            currBlockBuilder.lasts[1] = incrementorBlockBuilder;
+            const incrementorBlock = new BasicBlock_1.BasicBlock();
+            blockBuilderToCfgBlock.set(incrementorBlockBuilder, incrementorBlock);
+            stmtsReenterCondition.forEach(stmt => incrementorBlock.getStmts().push(stmt));
+            const currBlock = blockBuilderToCfgBlock.get(currBlockBuilder);
+            incrementorBlock.getPredecessors().push(currBlock);
+            currBlock.setPredecessorBlock(1, incrementorBlock);
+            incrementorBlock.addSuccessorBlock(currBlock);
+            currBlock.setSuccessorBlock(0, incrementorBlock);
+            basicBlockSet.add(incrementorBlock);
+            return;
+        }
+        const blockBuildersReenterCondition = [];
+        for (const prevBlockBuilder of currBlockBuilder.lasts) {
+            const prevBlock = blockBuilderToCfgBlock.get(prevBlockBuilder);
+            if (prevBlock.getId() > currBlockId) {
+                blockBuildersReenterCondition.push(prevBlockBuilder);
+            }
+        }
+        if (blockBuildersReenterCondition.length > 1 ||
+            blockBuildersReenterCondition[0].nexts.length > 1 ||
+            blocksContainLoopCondition.has(blockBuildersReenterCondition[0])) {
+            // put incrementor statements into an extra block
+            this.insertBeforeConditionBlockBuilder(blockBuilderToCfgBlock, currBlockBuilder, stmtsReenterCondition, true, basicBlockSet, blockBuilders);
+        }
+        else {
+            // put incrementor statements into prev reenter block
+            const blockReenterCondition = blockBuilderToCfgBlock.get(blockBuildersReenterCondition[0]);
+            stmtsReenterCondition.forEach(stmt => blockReenterCondition === null || blockReenterCondition === void 0 ? void 0 : blockReenterCondition.getStmts().push(stmt));
+        }
+    }
+}
+exports.CxxLoopBuilder = CxxLoopBuilder;

package/lib/frontend/cppFrontend/graph/builder/SwitchBuilder.d.ts

@@ -0,0 +1,12 @@
+import { BasicBlock } from '../../../../core/graph/BasicBlock';
+import { ArkIRTransformer, ValueAndStmts } from '../../../../core/common/ArkIRTransformer';
+import { BlockBuilder } from '../../../../core/graph/builder/CfgBuilder';
+/**
+ * Builder for switch statement in CFG
+ */
+export declare class CxxSwitchBuilder {
+    buildSwitch(blockBuilderToCfgBlock: Map<BlockBuilder, BasicBlock>, blockBuildersContainSwitch: BlockBuilder[], valueAndStmtsOfSwitchAndCasesAll: ValueAndStmts[][], arkIRTransformer: ArkIRTransformer, basicBlockSet: Set<BasicBlock>): void;
+    private generateIfBlocksForCases;
+    private linkIfBlockAndCaseBlock;
+}
+//# sourceMappingURL=SwitchBuilder.d.ts.map

package/lib/frontend/cppFrontend/graph/builder/SwitchBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwitchBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/graph/builder/SwitchBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AAE3F,OAAO,EAAE,YAAY,EAA0B,MAAM,2CAA2C,CAAC;AAKjG;;GAEG;AACH,qBAAa,gBAAgB;IAClB,WAAW,CACd,sBAAsB,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,EACrD,0BAA0B,EAAE,YAAY,EAAE,EAC1C,gCAAgC,EAAE,aAAa,EAAE,EAAE,EACnD,gBAAgB,EAAE,gBAAgB,EAClC,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,GAC/B,IAAI;IA0CP,OAAO,CAAC,wBAAwB;IAwChC,OAAO,CAAC,uBAAuB;CAmDlC"}

package/lib/frontend/cppFrontend/graph/builder/SwitchBuilder.js

@@ -0,0 +1,155 @@
+"use strict";
+/*
+ * Copyright (c) 2025 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.CxxSwitchBuilder = void 0;
+const BasicBlock_1 = require("../../../../core/graph/BasicBlock");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'SwitchBuilder');
+/**
+ * Builder for switch statement in CFG
+ */
+class CxxSwitchBuilder {
+    buildSwitch(blockBuilderToCfgBlock, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll, arkIRTransformer, basicBlockSet) {
+        for (let i = 0; i < blockBuildersContainSwitch.length; i++) {
+            const blockBuilderContainSwitch = blockBuildersContainSwitch[i];
+            if (!blockBuilderToCfgBlock.has(blockBuilderContainSwitch)) {
+                logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
+                continue;
+            }
+            const blockContainSwitch = blockBuilderToCfgBlock.get(blockBuilderContainSwitch);
+            const valueAndStmtsOfSwitch = valueAndStmtsOfSwitchAndCasesAll[i][0];
+            const stmtsOfSwitch = valueAndStmtsOfSwitch.stmts;
+            stmtsOfSwitch.forEach((stmt) => {
+                blockContainSwitch.addStmt(stmt);
+            });
+            const stmtsCnt = blockBuilderContainSwitch.stmts.length;
+            const switchStmtBuilder = blockBuilderContainSwitch.stmts[stmtsCnt - 1];
+            const cases = switchStmtBuilder.cases;
+            let nonEmptyCaseCnt = 0;
+            for (const currCase of cases) {
+                if (currCase.stmt.block) {
+                    // there are stmts after this case
+                    nonEmptyCaseCnt++;
+                }
+            }
+            if (nonEmptyCaseCnt === 0) {
+                continue;
+            }
+            const caseCnt = cases.length;
+            const caseIfBlocks = this.generateIfBlocksForCases(valueAndStmtsOfSwitchAndCasesAll[i], caseCnt, blockContainSwitch, basicBlockSet, arkIRTransformer);
+            this.linkIfBlockAndCaseBlock(blockContainSwitch, caseIfBlocks, switchStmtBuilder, blockBuilderToCfgBlock);
+        }
+    }
+    generateIfBlocksForCases(valueAndStmtsOfSwitchAndCases, caseCnt, blockContainSwitch, basicBlockSet, arkIRTransformer) {
+        const valueAndStmtsOfSwitch = valueAndStmtsOfSwitchAndCases[0];
+        const valueOfSwitch = valueAndStmtsOfSwitch.value;
+        const caseIfBlocks = [];
+        for (let j = 0; j < caseCnt; j++) {
+            let caseIfBlock;
+            if (j === 0) {
+                caseIfBlock = blockContainSwitch;
+            }
+            else {
+                caseIfBlock = new BasicBlock_1.BasicBlock();
+                basicBlockSet.add(caseIfBlock);
+            }
+            caseIfBlocks.push(caseIfBlock);
+            const caseValueAndStmts = valueAndStmtsOfSwitchAndCases[j + 1];
+            const caseValue = caseValueAndStmts.value;
+            const caseStmts = caseValueAndStmts.stmts;
+            caseStmts.forEach((stmt) => {
+                caseIfBlock.addStmt(stmt);
+            });
+            const caseIfStmts = arkIRTransformer.generateIfStmtForValues(valueOfSwitch, valueAndStmtsOfSwitch.valueOriginalPositions, caseValue, caseValueAndStmts.valueOriginalPositions);
+            caseIfStmts.forEach((stmt) => {
+                caseIfBlock.addStmt(stmt);
+            });
+        }
+        return caseIfBlocks;
+    }
+    linkIfBlockAndCaseBlock(blockContainSwitch, caseIfBlocks, switchStmtBuilder, blockBuilderToCfgBlock) {
+        const successorsOfBlockContainSwitch = Array.from(blockContainSwitch.getSuccessors());
+        const expectedSuccessorsOfCaseIfBlock = [];
+        const defaultStmtBuilder = switchStmtBuilder.default;
+        if (defaultStmtBuilder && defaultStmtBuilder.block) {
+            expectedSuccessorsOfCaseIfBlock.push(...successorsOfBlockContainSwitch.splice(-1, 1));
+        }
+        else {
+            const afterSwitchStmtBuilder = switchStmtBuilder.afterSwitch;
+            const afterSwitchBlockBuilder = afterSwitchStmtBuilder === null || afterSwitchStmtBuilder === void 0 ? void 0 : afterSwitchStmtBuilder.block;
+            if (!afterSwitchBlockBuilder || !blockBuilderToCfgBlock.has(afterSwitchBlockBuilder)) {
+                logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
+                return false;
+            }
+            expectedSuccessorsOfCaseIfBlock.push(blockBuilderToCfgBlock.get(afterSwitchBlockBuilder));
+        }
+        const caseCnt = switchStmtBuilder.cases.length;
+        for (let i = caseCnt - 1; i >= 0; i--) {
+            const currCase = switchStmtBuilder.cases[i];
+            if (currCase.stmt.block || currCase.stmt.type === 'gotoStatement') {
+                expectedSuccessorsOfCaseIfBlock.push(...successorsOfBlockContainSwitch.splice(-1, 1));
+            }
+            else {
+                // if there are no stmts after this case, reuse the successor of the next case
+                expectedSuccessorsOfCaseIfBlock.push(...expectedSuccessorsOfCaseIfBlock.slice(-1));
+            }
+        }
+        expectedSuccessorsOfCaseIfBlock.reverse();
+        blockContainSwitch.getSuccessors().forEach(successor => {
+            successor.getPredecessors().splice(0, 1);
+        });
+        blockContainSwitch.getSuccessors().splice(0);
+        for (let j = 0; j < caseCnt; j++) {
+            const caseIfBlock = caseIfBlocks[j];
+            caseIfBlock.addSuccessorBlock(expectedSuccessorsOfCaseIfBlock[j]);
+            expectedSuccessorsOfCaseIfBlock[j].addPredecessorBlock(caseIfBlock);
+            if (j === caseCnt - 1) {
+                // the false branch of last case should be default or block after switch statement
+                caseIfBlock.addSuccessorBlock(expectedSuccessorsOfCaseIfBlock[j + 1]);
+                expectedSuccessorsOfCaseIfBlock[j + 1].addPredecessorBlock(caseIfBlock);
+            }
+            else {
+                caseIfBlock.addSuccessorBlock(caseIfBlocks[j + 1]);
+                caseIfBlocks[j + 1].addPredecessorBlock(caseIfBlock);
+            }
+        }
+        return true;
+    }
+}
+exports.CxxSwitchBuilder = CxxSwitchBuilder;

package/lib/frontend/cppFrontend/graph/builder/TrapBuilder.d.ts

@@ -0,0 +1,29 @@
+import { BasicBlock } from '../../../../core/graph/BasicBlock';
+import { CxxTrap } from '../../base/Trap';
+import { BlockBuilder } from './CfgBuilder';
+/**
+ * Builder for traps from try...catch
+ */
+export declare class CxxTrapBuilder {
+    private processedBlockBuildersBeforeTry;
+    private basicBlockSet;
+    private blockBuilderToCfgBlock;
+    private blockBuildersBeforeTry;
+    constructor(blockBuildersBeforeTry: Set<BlockBuilder>, blockBuilderToCfgBlock: Map<BlockBuilder, BasicBlock>, basicBlockSet: Set<BasicBlock>);
+    buildTraps(): CxxTrap[];
+    private buildTrapGroup;
+    private shouldSkipProcessing;
+    private getTryStatementBuilder;
+    private getFinallyBlock;
+    private prepareHeadBlock;
+    private processTryBlock;
+    private processCatchBlock;
+    private getAfterFinallyBlock;
+    private buildSingleTraps;
+    private buildTrapsRecursively;
+    private removeEmptyBlockBeforeTry;
+    private shouldRemoveEmptyBlockBeforeTry;
+    private buildTrapsIfNoFinally;
+    private getAllBlocksBFS;
+}
+//# sourceMappingURL=TrapBuilder.d.ts.map

package/lib/frontend/cppFrontend/graph/builder/TrapBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrapBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/graph/builder/TrapBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAuB,MAAM,cAAc,CAAC;AAKjE;;GAEG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,+BAA+B,CAAoB;IAC3D,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,sBAAsB,CAAgC;IAC9D,OAAO,CAAC,sBAAsB,CAAoB;gBAEtC,sBAAsB,EAAE,GAAG,CAAC,YAAY,CAAC,EAAE,sBAAsB,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,EACxG,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC;IAO3B,UAAU,IAAI,OAAO,EAAE;IAS9B,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,oBAAoB;IAa5B,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,iBAAiB;IA0BzB,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,qBAAqB;IAkC7B,OAAO,CAAC,yBAAyB;IAyBjC,OAAO,CAAC,+BAA+B;IAMvC,OAAO,CAAC,qBAAqB;IA0D7B,OAAO,CAAC,eAAe;CAkC1B"}