arkanalyzer 1.0.86 → 1.0.88

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

@@ -0,0 +1,21 @@
+import { BasicBlock } from '../../../../core/graph/BasicBlock';
+import { BlockBuilder } from '../../../../core/graph/builder/CfgBuilder';
+/**
+ * Builder for condition in CFG
+ */
+export declare class CxxConditionBuilder {
+    rebuildBlocksContainConditionalOperator(blockBuilderToCfgBlock: Map<BlockBuilder, BasicBlock>, basicBlockSet: Set<BasicBlock>, isArkUIBuilder: boolean): void;
+    private relinkPrevAndSuccOfBlockContainConditionalOperator;
+    private generateBlocksContainConditionalOperatorGroup;
+    private segmentSourceStatements;
+    private initializeSuffix;
+    private addBlocksToSet;
+    private linkBlocks;
+    private generateBlocksContainSingleConditionalOperator;
+    private generateBlockWithoutConditionalOperator;
+    private deleteDummyConditionalOperatorStmt;
+    private findFirstConditionalOperator;
+    private removeUnnecessaryBlocksInConditionalOperator;
+    private replaceTempRecursively;
+}
+//# sourceMappingURL=ConditionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/graph/builder/ConditionBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAK/D,OAAO,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAazE;;GAEG;AACH,qBAAa,mBAAmB;IACrB,uCAAuC,CAC1C,sBAAsB,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,EACrD,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,EAC9B,cAAc,EAAE,OAAO,GACxB,IAAI;IAmDP,OAAO,CAAC,kDAAkD;IAuB1D,OAAO,CAAC,6CAA6C;IAgCrD,OAAO,CAAC,uBAAuB;IAyB/B,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,8CAA8C;IAqDtD,OAAO,CAAC,uCAAuC;IAc/C,OAAO,CAAC,kCAAkC;IAW1C,OAAO,CAAC,4BAA4B;IAyBpC,OAAO,CAAC,4CAA4C;IAoCpD,OAAO,CAAC,sBAAsB;CA2DjC"}

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

@@ -0,0 +1,303 @@
+"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.CxxConditionBuilder = void 0;
+const BasicBlock_1 = require("../../../../core/graph/BasicBlock");
+const ArkIRTransformer_1 = require("../../../../core/common/ArkIRTransformer");
+const Stmt_1 = require("../../../../core/base/Stmt");
+const Local_1 = require("../../../../core/base/Local");
+const IRUtils_1 = require("../../common/IRUtils");
+/**
+ * Builder for condition in CFG
+ */
+class CxxConditionBuilder {
+    rebuildBlocksContainConditionalOperator(blockBuilderToCfgBlock, basicBlockSet, isArkUIBuilder) {
+        var _a;
+        if (isArkUIBuilder) {
+            this.deleteDummyConditionalOperatorStmt(basicBlockSet);
+            return;
+        }
+        const blockPairsToSet = [];
+        for (const [currBlockBuilder, currBasicBlock] of blockBuilderToCfgBlock) {
+            const stmtsInCurrBasicBlock = Array.from(currBasicBlock.getStmts());
+            const stmtsCnt = stmtsInCurrBasicBlock.length;
+            let conditionalOperatorEndPos = -1;
+            for (let i = stmtsCnt - 1; i >= 0; i--) {
+                const stmt = stmtsInCurrBasicBlock[i];
+                if (stmt instanceof ArkIRTransformer_1.DummyStmt && ((_a = stmt.toString()) === null || _a === void 0 ? void 0 : _a.startsWith(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT))) {
+                    conditionalOperatorEndPos = i;
+                    break;
+                }
+            }
+            if (conditionalOperatorEndPos === -1) {
+                continue;
+            }
+            let { generatedTopBlock: generatedTopBlock, generatedBottomBlocks: generatedBottomBlocks, } = this.generateBlocksContainConditionalOperatorGroup(stmtsInCurrBasicBlock.slice(0, conditionalOperatorEndPos + 1), basicBlockSet);
+            if (conditionalOperatorEndPos !== stmtsCnt - 1) {
+                // need create a new basic block for rest statements
+                const { generatedTopBlock: extraBlock } = this.generateBlockWithoutConditionalOperator(stmtsInCurrBasicBlock.slice(conditionalOperatorEndPos + 1));
+                generatedBottomBlocks.forEach(generatedBottomBlock => {
+                    generatedBottomBlock.addSuccessorBlock(extraBlock);
+                    extraBlock.addPredecessorBlock(generatedBottomBlock);
+                });
+                basicBlockSet.add(extraBlock);
+                generatedBottomBlocks = this.removeUnnecessaryBlocksInConditionalOperator(extraBlock, basicBlockSet);
+            }
+            this.relinkPrevAndSuccOfBlockContainConditionalOperator(currBasicBlock, generatedTopBlock, generatedBottomBlocks);
+            basicBlockSet.delete(currBasicBlock);
+            blockPairsToSet.push([currBlockBuilder, generatedTopBlock]);
+        }
+        for (const [currBlockBuilder, generatedTopBlock] of blockPairsToSet) {
+            blockBuilderToCfgBlock.set(currBlockBuilder, generatedTopBlock);
+        }
+    }
+    relinkPrevAndSuccOfBlockContainConditionalOperator(currBasicBlock, generatedTopBlock, generatedBottomBlocks) {
+        const predecessorsOfCurrBasicBlock = Array.from(currBasicBlock.getPredecessors());
+        predecessorsOfCurrBasicBlock.forEach(predecessor => {
+            predecessor.removeSuccessorBlock(currBasicBlock);
+            currBasicBlock.removePredecessorBlock(predecessor);
+            generatedTopBlock.addPredecessorBlock(predecessor);
+            predecessor.addSuccessorBlock(generatedTopBlock);
+        });
+        const successorsOfCurrBasicBlock = Array.from(currBasicBlock.getSuccessors());
+        successorsOfCurrBasicBlock.forEach(successor => {
+            successor.removePredecessorBlock(currBasicBlock);
+            currBasicBlock.removeSuccessorBlock(successor);
+            generatedBottomBlocks.forEach(generatedBottomBlock => {
+                generatedBottomBlock.addSuccessorBlock(successor);
+                successor.addPredecessorBlock(generatedBottomBlock);
+            });
+        });
+    }
+    generateBlocksContainConditionalOperatorGroup(sourceStmts, basicBlockSet) {
+        const { segs, tail } = this.segmentSourceStatements(sourceStmts, basicBlockSet);
+        // Case 1: No conditional operators found, or only a trailing non-operator block
+        if (segs.length === 0) {
+            return tail !== null && tail !== void 0 ? tail : this.generateBlockWithoutConditionalOperator(sourceStmts);
+        }
+        // Case 2: Multi-segment linking
+        let { suffixTop, suffixBottoms } = this.initializeSuffix(segs, tail);
+        // Backward link segments: Seg[i].bottoms -> Seg[i+1].top
+        for (let i = segs.length - 1; i >= 0; i--) {
+            // Skip the last segment if there's no tail, as it's already the initial suffix
+            if (i === segs.length - 1 && !tail) {
+                continue;
+            }
+            const cur = segs[i];
+            this.linkBlocks(cur.bottoms, suffixTop);
+            this.addBlocksToSet(suffixBottoms, basicBlockSet);
+            this.removeUnnecessaryBlocksInConditionalOperator(suffixTop, basicBlockSet);
+            suffixTop = cur.top;
+        }
+        return { generatedTopBlock: segs[0].top, generatedBottomBlocks: suffixBottoms };
+    }
+    segmentSourceStatements(sourceStmts, basicBlockSet) {
+        const segs = [];
+        let offset = 0;
+        let tail;
+        while (offset < sourceStmts.length) {
+            const rest = sourceStmts.slice(offset);
+            const { firstEndPos } = this.findFirstConditionalOperator(rest);
+            if (firstEndPos === -1) {
+                tail = this.generateBlockWithoutConditionalOperator(rest);
+                break;
+            }
+            const result = this.generateBlocksContainSingleConditionalOperator(rest.slice(0, firstEndPos + 1));
+            this.addBlocksToSet(result.generatedAllBlocks, basicBlockSet);
+            segs.push({ top: result.generatedTopBlock, bottoms: result.generatedBottomBlocks });
+            offset += firstEndPos + 1;
+        }
+        return { segs, tail };
+    }
+    initializeSuffix(segs, tail) {
+        if (tail) {
+            return { suffixTop: tail.generatedTopBlock, suffixBottoms: tail.generatedBottomBlocks };
+        }
+        const last = segs[segs.length - 1];
+        return { suffixTop: last.top, suffixBottoms: last.bottoms };
+    }
+    addBlocksToSet(blocks, set) {
+        for (const b of blocks) {
+            set.add(b);
+        }
+    }
+    linkBlocks(from, to) {
+        for (const b of from) {
+            b.addSuccessorBlock(to);
+            to.addPredecessorBlock(b);
+        }
+    }
+    generateBlocksContainSingleConditionalOperator(sourceStmts) {
+        const { firstIfTruePos: ifTruePos, firstIfFalsePos: ifFalsePos, firstEndPos: endPos, } = this.findFirstConditionalOperator(sourceStmts);
+        if (endPos === -1) {
+            return this.generateBlockWithoutConditionalOperator(sourceStmts);
+        }
+        const { generatedTopBlock: generatedTopBlock, generatedAllBlocks: generatedAllBlocks, } = this.generateBlockWithoutConditionalOperator(sourceStmts.slice(0, ifTruePos));
+        let generatedBottomBlocks = [];
+        const { generatedTopBlock: generatedTopBlockOfTrueBranch, generatedBottomBlocks: generatedBottomBlocksOfTrueBranch, generatedAllBlocks: generatedAllBlocksOfTrueBranch, } = this.generateBlocksContainSingleConditionalOperator(sourceStmts.slice(ifTruePos + 1, ifFalsePos));
+        generatedBottomBlocks.push(...generatedBottomBlocksOfTrueBranch);
+        generatedAllBlocks.push(...generatedAllBlocksOfTrueBranch);
+        const { generatedTopBlock: generatedTopBlockOfFalseBranch, generatedBottomBlocks: generatedBottomBlocksOfFalseBranch, generatedAllBlocks: generatedAllBlocksOfFalseBranch, } = this.generateBlocksContainSingleConditionalOperator(sourceStmts.slice(ifFalsePos + 1, endPos));
+        generatedBottomBlocks.push(...generatedBottomBlocksOfFalseBranch);
+        generatedAllBlocks.push(...generatedAllBlocksOfFalseBranch);
+        generatedTopBlock.addSuccessorBlock(generatedTopBlockOfTrueBranch);
+        generatedTopBlockOfTrueBranch.addPredecessorBlock(generatedTopBlock);
+        generatedTopBlock.addSuccessorBlock(generatedTopBlockOfFalseBranch);
+        generatedTopBlockOfFalseBranch.addPredecessorBlock(generatedTopBlock);
+        const stmtsCnt = sourceStmts.length;
+        if (endPos !== stmtsCnt - 1) {
+            // need create a new basic block for rest statements
+            const { generatedTopBlock: extraBlock } = this.generateBlockWithoutConditionalOperator(sourceStmts.slice(endPos + 1));
+            generatedBottomBlocks.forEach(generatedBottomBlock => {
+                generatedBottomBlock.addSuccessorBlock(extraBlock);
+                extraBlock.addPredecessorBlock(generatedBottomBlock);
+            });
+            generatedBottomBlocks = [extraBlock];
+            generatedAllBlocks.push(extraBlock);
+        }
+        return { generatedTopBlock, generatedBottomBlocks, generatedAllBlocks };
+    }
+    generateBlockWithoutConditionalOperator(sourceStmts) {
+        const generatedBlock = new BasicBlock_1.BasicBlock();
+        sourceStmts.forEach(stmt => generatedBlock.addStmt(stmt));
+        return {
+            generatedTopBlock: generatedBlock,
+            generatedBottomBlocks: [generatedBlock],
+            generatedAllBlocks: [generatedBlock],
+        };
+    }
+    deleteDummyConditionalOperatorStmt(basicBlockSet) {
+        var _a;
+        for (const basicBlock of basicBlockSet) {
+            const stmts = Array.from(basicBlock.getStmts());
+            for (const stmt of stmts) {
+                if (stmt instanceof ArkIRTransformer_1.DummyStmt && ((_a = stmt.toString()) === null || _a === void 0 ? void 0 : _a.startsWith(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR))) {
+                    basicBlock.remove(stmt);
+                }
+            }
+        }
+    }
+    findFirstConditionalOperator(stmts) {
+        let firstIfTruePos = -1;
+        let firstIfFalsePos = -1;
+        let firstEndPos = -1;
+        let firstConditionalOperatorNo = '';
+        for (let i = 0; i < stmts.length; i++) {
+            const stmt = stmts[i];
+            if (stmt instanceof ArkIRTransformer_1.DummyStmt) {
+                if (stmt.toString().startsWith(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT) && firstIfTruePos === -1) {
+                    firstIfTruePos = i;
+                    firstConditionalOperatorNo = stmt.toString().replace(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT, '');
+                }
+                else if (stmt.toString() === ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_FALSE_STMT + firstConditionalOperatorNo) {
+                    firstIfFalsePos = i;
+                }
+                else if (stmt.toString() === ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT + firstConditionalOperatorNo) {
+                    firstEndPos = i;
+                }
+            }
+        }
+        return { firstIfTruePos, firstIfFalsePos, firstEndPos };
+    }
+    removeUnnecessaryBlocksInConditionalOperator(bottomBlock, allBlocks) {
+        var _a;
+        const firstStmtInBottom = bottomBlock.getHead();
+        if (!(firstStmtInBottom instanceof Stmt_1.ArkAssignStmt)) {
+            return [bottomBlock];
+        }
+        const targetValue = firstStmtInBottom.getLeftOp();
+        const targetValuePosition = (_a = firstStmtInBottom.getOperandOriginalPosition(targetValue)) !== null && _a !== void 0 ? _a : undefined;
+        const tempResultValue = firstStmtInBottom.getRightOp();
+        if (!(targetValue instanceof Local_1.Local && IRUtils_1.IRUtils.isTempLocal(tempResultValue))) {
+            return [bottomBlock];
+        }
+        const oldPredecessors = Array.from(bottomBlock.getPredecessors());
+        const newPredecessors = [];
+        for (const predecessor of oldPredecessors) {
+            predecessor.removeSuccessorBlock(bottomBlock);
+            newPredecessors.push(...this.replaceTempRecursively(predecessor, targetValue, tempResultValue, allBlocks, targetValuePosition));
+        }
+        bottomBlock.remove(firstStmtInBottom);
+        if (bottomBlock.getStmts().length === 0) {
+            // must be a new block without successors
+            allBlocks.delete(bottomBlock);
+            return newPredecessors;
+        }
+        oldPredecessors.forEach(oldPredecessor => {
+            bottomBlock.removePredecessorBlock(oldPredecessor);
+        });
+        newPredecessors.forEach(newPredecessor => {
+            bottomBlock.addPredecessorBlock(newPredecessor);
+            newPredecessor.addSuccessorBlock(bottomBlock);
+        });
+        return [bottomBlock];
+    }
+    replaceTempRecursively(currBottomBlock, targetLocal, tempResultLocal, allBlocks, targetValuePosition) {
+        var _a;
+        const stmts = currBottomBlock.getStmts();
+        const stmtsCnt = stmts.length;
+        let tempResultReassignStmt = null;
+        for (let i = stmtsCnt - 1; i >= 0; i--) {
+            const stmt = stmts[i];
+            if (!(stmt instanceof Stmt_1.ArkAssignStmt) || stmt.getLeftOp() !== tempResultLocal) {
+                continue;
+            }
+            if (IRUtils_1.IRUtils.isTempLocal(stmt.getRightOp())) {
+                // When only one stmt remains in a block, it should be retained, and the final value of the ternary expression should be concatenated with it
+                tempResultReassignStmt = stmt;
+                if (i !== 0) {
+                    continue;
+                }
+            }
+            stmt.setLeftOp(targetLocal);
+            if (targetValuePosition) {
+                const restPositions = (_a = stmt.getOperandOriginalPositions()) === null || _a === void 0 ? void 0 : _a.slice(1);
+                if (restPositions) {
+                    stmt.setOperandOriginalPositions([targetValuePosition, ...restPositions]);
+                }
+            }
+        }
+        let newBottomBlocks = [];
+        // When both ends are TempLocal, the statement begins filtering
+        if (tempResultReassignStmt && IRUtils_1.IRUtils.isTempLocal(tempResultReassignStmt.getLeftOp())) {
+            const oldPredecessors = currBottomBlock.getPredecessors();
+            const newPredecessors = [];
+            const prevTempResultLocal = tempResultReassignStmt.getRightOp();
+            for (const predecessor of oldPredecessors) {
+                predecessor.removeSuccessorBlock(currBottomBlock);
+                newPredecessors.push(...this.replaceTempRecursively(predecessor, targetLocal, prevTempResultLocal, allBlocks, targetValuePosition));
+            }
+            currBottomBlock.remove(tempResultReassignStmt);
+            if (currBottomBlock.getStmts().length === 0) {
+                // remove this block
+                newBottomBlocks = newPredecessors;
+                allBlocks.delete(currBottomBlock);
+            }
+            else {
+                currBottomBlock.getPredecessors().splice(0, oldPredecessors.length, ...newPredecessors);
+                newPredecessors.forEach(newPredecessor => {
+                    newPredecessor.addSuccessorBlock(currBottomBlock);
+                });
+                newBottomBlocks = [currBottomBlock];
+            }
+        }
+        else {
+            newBottomBlocks = [currBottomBlock];
+        }
+        return newBottomBlocks;
+    }
+}
+exports.CxxConditionBuilder = CxxConditionBuilder;

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

@@ -0,0 +1,15 @@
+import { BasicBlock } from '../../../../core/graph/BasicBlock';
+/**
+ * Builder for if statement in CFG
+ * This is a scenario where the processing criteria include | | or &&
+ */
+export declare class CxxIfBuilder {
+    rebuildIf(basicBlockSet: Set<BasicBlock>): void;
+    private generateBlocksForComplexBooleanExpr;
+    private generateBlocksForOrExpr;
+    private generateBlocksForAndExpr;
+    private findOrOperator;
+    private findAndOperator;
+    private generateBlock;
+}
+//# sourceMappingURL=IfBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IfBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/graph/builder/IfBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAQ/D;;;GAGG;AACH,qBAAa,YAAY;IACd,SAAS,CACZ,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,GAC/B,IAAI;IAYP,OAAO,CAAC,mCAAmC;IAmB3C,OAAO,CAAC,uBAAuB;IAqB/B,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,aAAa;CAcxB"}

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

@@ -0,0 +1,161 @@
+"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.CxxIfBuilder = void 0;
+const BasicBlock_1 = require("../../../../core/graph/BasicBlock");
+const ArkIRTransformer_1 = require("../../../../core/common/ArkIRTransformer");
+const logger_1 = __importStar(require("../../../../utils/logger"));
+const ArkIRTransformer_2 = require("../../common/ArkIRTransformer");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'SwitchBuilder');
+/**
+ * Builder for if statement in CFG
+ * This is a scenario where the processing criteria include | | or &&
+ */
+class CxxIfBuilder {
+    rebuildIf(basicBlockSet) {
+        var _a;
+        for (const basicBlock of basicBlockSet) {
+            const stmts = Array.from(basicBlock.getStmts());
+            const stmtsCnt = stmts.length;
+            const stmt = stmts[stmtsCnt - 1];
+            if (stmt instanceof ArkIRTransformer_1.DummyStmt && ((_a = stmt.toString()) === null || _a === void 0 ? void 0 : _a.startsWith(ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END))) {
+                this.generateBlocksForComplexBooleanExpr(basicBlock, basicBlockSet);
+            }
+        }
+    }
+    generateBlocksForComplexBooleanExpr(block, basicBlockSet) {
+        if (block.getSuccessors().length !== 2) {
+            logger.error('the ifStmt build failed');
+            return;
+        }
+        const { firstOrSignalPos: firstOrSignalPos, firstOrEndPos: OrEndPos } = this.findOrOperator(block.getStmts());
+        if (firstOrSignalPos !== -1) {
+            this.generateBlocksForOrExpr(block, basicBlockSet, firstOrSignalPos, OrEndPos);
+            return;
+        }
+        const { firstAndSignalPos: firstAndSignalPos, firstAndEndPos: AndEndPos, } = this.findAndOperator(block.getStmts());
+        if (firstAndSignalPos !== -1) {
+            this.generateBlocksForAndExpr(block, basicBlockSet, firstAndSignalPos, AndEndPos);
+        }
+    }
+    generateBlocksForOrExpr(block, basicBlockSet, firstOrSignalPos, OrEndPos) {
+        const sourceStmts = block.getStmts();
+        const { generatedTopBlock: secondBlock } = this.generateBlock(sourceStmts.slice(firstOrSignalPos + 1, OrEndPos));
+        sourceStmts.splice(firstOrSignalPos);
+        const falseBlock = block.getSuccessors()[1];
+        const trueBlock = block.getSuccessors()[0];
+        block.removeSuccessorBlock(falseBlock);
+        falseBlock.removePredecessorBlock(block);
+        block.addSuccessorBlock(secondBlock);
+        secondBlock.addPredecessorBlock(block);
+        secondBlock.addSuccessorBlock(trueBlock);
+        trueBlock.addPredecessorBlock(secondBlock);
+        secondBlock.addSuccessorBlock(falseBlock);
+        falseBlock.addPredecessorBlock(secondBlock);
+        basicBlockSet.add(secondBlock);
+        this.generateBlocksForComplexBooleanExpr(block, basicBlockSet);
+        this.generateBlocksForComplexBooleanExpr(secondBlock, basicBlockSet);
+    }
+    generateBlocksForAndExpr(block, basicBlockSet, firstOrSignalPos, OrEndPos) {
+        const sourceStmts = block.getStmts();
+        const { generatedTopBlock: secondBlock } = this.generateBlock(sourceStmts.slice(firstOrSignalPos + 1, OrEndPos));
+        sourceStmts.splice(firstOrSignalPos);
+        // Need to check if it is the default rule
+        const falseBlock = block.getSuccessors()[1];
+        const trueBlock = block.getSuccessors()[0];
+        block.removeSuccessorBlock(trueBlock);
+        trueBlock.removePredecessorBlock(block);
+        const successesBlock = block.getSuccessors();
+        successesBlock.unshift(secondBlock);
+        secondBlock.addPredecessorBlock(block);
+        secondBlock.addSuccessorBlock(trueBlock);
+        trueBlock.addPredecessorBlock(secondBlock);
+        secondBlock.addSuccessorBlock(falseBlock);
+        falseBlock.addPredecessorBlock(secondBlock);
+        basicBlockSet.add(secondBlock);
+        this.generateBlocksForComplexBooleanExpr(block, basicBlockSet);
+        this.generateBlocksForComplexBooleanExpr(secondBlock, basicBlockSet);
+    }
+    findOrOperator(stmts) {
+        let firstOrSignalPos = -1;
+        let firstOrEndPos = -1;
+        let firstConditionalOperatorNo = '';
+        for (let i = stmts.length; i >= 0; i--) {
+            const stmt = stmts[i];
+            if (stmt instanceof ArkIRTransformer_1.DummyStmt) {
+                if (stmt.toString().startsWith(ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END) && firstOrEndPos === -1) {
+                    firstOrEndPos = i;
+                    firstConditionalOperatorNo = stmt.toString().replace(ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END, '');
+                }
+                else if (stmt.toString() === ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_OR_SIGNAL + firstConditionalOperatorNo) {
+                    firstOrSignalPos = i;
+                }
+            }
+        }
+        return { firstOrSignalPos, firstOrEndPos };
+    }
+    findAndOperator(stmts) {
+        let firstAndSignalPos = -1;
+        let firstAndEndPos = -1;
+        let firstConditionalOperatorNo = '';
+        for (let i = stmts.length; i >= 0; i--) {
+            const stmt = stmts[i];
+            if (stmt instanceof ArkIRTransformer_1.DummyStmt) {
+                if (stmt.toString().startsWith(ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END) && firstAndEndPos === -1) {
+                    firstAndEndPos = i;
+                    firstConditionalOperatorNo = stmt.toString().replace(ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END, '');
+                }
+                else if (stmt.toString() === ArkIRTransformer_2.ArkCxxIRTransformer.DUMMY_IF_OPERATOR_AND_SIGNAL + firstConditionalOperatorNo) {
+                    firstAndSignalPos = i;
+                }
+            }
+        }
+        return { firstAndSignalPos, firstAndEndPos };
+    }
+    generateBlock(sourceStmts) {
+        const generatedBlock = new BasicBlock_1.BasicBlock();
+        sourceStmts.forEach(stmt => generatedBlock.addStmt(stmt));
+        return {
+            generatedTopBlock: generatedBlock,
+            generatedBottomBlocks: [generatedBlock],
+            generatedAllBlocks: [generatedBlock],
+        };
+    }
+}
+exports.CxxIfBuilder = CxxIfBuilder;

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

@@ -0,0 +1,21 @@
+import { BasicBlock } from '../../../../core/graph/BasicBlock';
+import { BlockBuilder } from './CfgBuilder';
+/**
+ * Builder for loop in CFG
+ */
+export declare class CxxLoopBuilder {
+    rebuildBlocksInLoop(blockBuilderToCfgBlock: Map<BlockBuilder, BasicBlock>, blocksContainLoopCondition: Set<BlockBuilder>, basicBlockSet: Set<BasicBlock>, blockBuilders: BlockBuilder[]): void;
+    private doesPrevBlockBuilderContainLoop;
+    private insertBeforeConditionBlockBuilder;
+    private getBlockFromMap;
+    private collectBlocksBeforeAndReenter;
+    private getCollectedBlocks;
+    private createAndLinkBlocks;
+    private updatePredecessors;
+    private getNewPrevBlocks;
+    private updateConditionBlockBuilder;
+    private finalizeInsertion;
+    private findIteratorIdx;
+    private adjustIncrementorStmts;
+}
+//# sourceMappingURL=LoopBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoopBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/graph/builder/LoopBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAI/D,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAI5C;;GAEG;AACH,qBAAa,cAAc;IAChB,mBAAmB,CACtB,sBAAsB,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,EACrD,0BAA0B,EAAE,GAAG,CAAC,YAAY,CAAC,EAC7C,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,EAC9B,aAAa,EAAE,YAAY,EAAE,GAC9B,IAAI;IAqEP,OAAO,CAAC,+BAA+B;IAWvC,OAAO,CAAC,iCAAiC;IA4DzC,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,6BAA6B;IAgCrC,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,mBAAmB;IAoB3B,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,gBAAgB;IA2BxB,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,eAAe;IAoCvB,OAAO,CAAC,sBAAsB;CAoDjC"}