Skip to content

Commit 6fd8f88

Browse files
darkbuckdarkbuck
committed
[CIR] Add 'core-flat' as an option value for '-emit-mlir='
- Both 'func' and 'scf' have structure control flow constraints, e.g., 'func.return' needs to have 'func.func' parent op. The alternative approach to lower CIR into MLIR standard dialects is to lower CIR into 'cf' dialect and then perform structurization on all or selected regions. - Add 'core-flat' option to enable CFG flattening when lowering CIR into MLIR standard dialects. - Enhance 'cir-flatten-cfg' pass to unify returns into branches to a dedicated return block. - Fix 'cir.br' and 'cir.return' lowering to MLIR and allow function declarations.
1 parent 7e4213f commit 6fd8f88

File tree

11 files changed

+266
-38
lines changed

11 files changed

+266
-38
lines changed

‎clang/include/clang/CIR/Dialect/Passes.h

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,13 +37,15 @@ std::unique_ptr<Pass> createIdiomRecognizerPass(clang::ASTContext *astCtx);
3737
std::unique_ptr<Pass> createLibOptPass();
3838
std::unique_ptr<Pass> createLibOptPass(clang::ASTContext *astCtx);
3939
std::unique_ptr<Pass> createFlattenCFGPass();
40+
std::unique_ptr<Pass> createFlattenCFGPass(bool throughMLIR);
4041
std::unique_ptr<Pass> createHoistAllocasPass();
4142
std::unique_ptr<Pass> createGotoSolverPass();
4243

4344
/// Create a pass to lower ABI-independent function definitions/calls.
4445
std::unique_ptr<Pass> createCallConvLoweringPass();
4546

46-
void populateCIRPreLoweringPasses(mlir::OpPassManager &pm, bool useCCLowering);
47+
void populateCIRPreLoweringPasses(mlir::OpPassManager &pm, bool useCCLowering,
48+
bool emitCore);
4749

4850
//===----------------------------------------------------------------------===//
4951
// Registration

‎clang/include/clang/CIR/Dialect/Passes.td

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,10 @@ def FlattenCFG : Pass<"cir-flatten-cfg"> {
127127
In other words, this pass removes such CIR operations like IfOp, LoopOp,
128128
ScopeOp and etc. and produces a flat CIR.
129129
}];
130+
let options = [
131+
Option<"throughMLIR", "through-mlir", "bool", /*default=*/"false",
132+
"Prepare the flat CIR for lowering through MLIR">,
133+
];
130134
let constructor = "mlir::createFlattenCFGPass()";
131135
let dependentDialects = ["cir::CIRDialect"];
132136
}

‎clang/include/clang/Driver/Options.td

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3120,9 +3120,9 @@ def emit_mlir : Flag<["-"], "emit-mlir">, Visibility<[ClangOption]>, Group<Actio
31203120
def emit_mlir_EQ : Joined<["-"], "emit-mlir=">, Visibility<[ClangOption, CC1Option]>, Group<Action_Group>,
31213121
HelpText<"Build ASTs and then lower through ClangIR to the selected MLIR dialect, emit the .mlir file. "
31223122
"Allowed values are `core` for MLIR standard dialects and `llvm` for the LLVM dialect.">,
3123-
Values<"core,llvm,cir,cir-flat">,
3123+
Values<"core,llvm,cir,cir-flat,core-flat">,
31243124
NormalizedValuesScope<"frontend">,
3125-
NormalizedValues<["MLIR_CORE", "MLIR_LLVM", "MLIR_CIR", "MLIR_CIR_FLAT"]>,
3125+
NormalizedValues<["MLIR_CORE", "MLIR_LLVM", "MLIR_CIR", "MLIR_CIR_FLAT", "MLIR_CORE_FLAT"]>,
31263126
MarshallingInfoEnum<FrontendOpts<"MLIRTargetDialect">, "MLIR_CORE">;
31273127
def emit_cir : Flag<["-"], "emit-cir">, Visibility<[ClangOption, CC1Option]>,
31283128
Group<Action_Group>, Alias<emit_mlir_EQ>, AliasArgs<["cir"]>,

‎clang/include/clang/Frontend/FrontendOptions.h

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -154,7 +154,13 @@ enum ActionKind {
154154
PrintDependencyDirectivesSourceMinimizerOutput
155155
};
156156

157-
enum MLIRDialectKind { MLIR_CORE, MLIR_LLVM, MLIR_CIR, MLIR_CIR_FLAT };
157+
enum MLIRDialectKind {
158+
MLIR_CORE,
159+
MLIR_LLVM,
160+
MLIR_CIR,
161+
MLIR_CIR_FLAT,
162+
MLIR_CORE_FLAT
163+
};
158164

159165
} // namespace frontend
160166

‎clang/lib/CIR/CodeGen/CIRPasses.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@ mlir::LogicalResult runCIRToCIRPasses(
7676
pm.addPass(mlir::createLoweringPreparePass(&astContext));
7777

7878
if (flattenCIR || enableMem2Reg)
79-
mlir::populateCIRPreLoweringPasses(pm, enableCallConvLowering);
79+
mlir::populateCIRPreLoweringPasses(pm, enableCallConvLowering, emitCore);
8080

8181
if (enableMem2Reg)
8282
pm.addPass(mlir::createMem2Reg());
@@ -96,11 +96,12 @@ mlir::LogicalResult runCIRToCIRPasses(
9696

9797
namespace mlir {
9898

99-
void populateCIRPreLoweringPasses(OpPassManager &pm, bool useCCLowering) {
99+
void populateCIRPreLoweringPasses(OpPassManager &pm, bool useCCLowering,
100+
bool emitCore) {
100101
if (useCCLowering)
101102
pm.addPass(createCallConvLoweringPass());
102103
pm.addPass(createHoistAllocasPass());
103-
pm.addPass(createFlattenCFGPass());
104+
pm.addPass(createFlattenCFGPass(/*throughMLIR=*/emitCore));
104105
pm.addPass(createGotoSolverPass());
105106
}
106107

‎clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,11 @@ struct FlattenCFGPass : public FlattenCFGBase<FlattenCFGPass> {
5050

5151
FlattenCFGPass() = default;
5252
void runOnOperation() override;
53+
54+
void setThroughMLIR(bool v) { throughMLIR = v; }
55+
56+
protected:
57+
void unifyReturn(FuncOp func);
5358
};
5459

5560
struct CIRIfFlattening : public OpRewritePattern<IfOp> {
@@ -906,6 +911,72 @@ class CIRTernaryOpFlattening : public mlir::OpRewritePattern<cir::TernaryOp> {
906911
}
907912
};
908913

914+
struct UnifyReturn : public OpRewritePattern<ReturnOp> {
915+
using OpRewritePattern<ReturnOp>::OpRewritePattern;
916+
917+
UnifyReturn(MLIRContext *context, cir::FuncOp func, Block *retBlock)
918+
: OpRewritePattern<ReturnOp>(context), func(func), retBlock(retBlock) {}
919+
920+
mlir::LogicalResult
921+
matchAndRewrite(cir::ReturnOp ret,
922+
mlir::PatternRewriter &rewriter) const override {
923+
mlir::OpBuilder::InsertionGuard guard(rewriter);
924+
auto fn = ret->getParentOfType<cir::FuncOp>();
925+
if (!fn || fn != func)
926+
return mlir::failure();
927+
// Replace 'return' with 'br <retBlock>'
928+
rewriter.replaceOpWithNewOp<cir::BrOp>(ret, ret.getInput(), retBlock);
929+
return mlir::success();
930+
}
931+
932+
private:
933+
cir::FuncOp func; // The parent funcOp
934+
Block *retBlock; // The dedicated return block
935+
};
936+
937+
void FlattenCFGPass::unifyReturn(cir::FuncOp func) {
938+
if (func.getRegion().empty())
939+
return;
940+
941+
// Collect operations to apply patterns.
942+
llvm::SmallVector<Operation *, 16> ops;
943+
bool hasReturnOpWithFuncOpParentOnly = true;
944+
unsigned numReturnOps = 0;
945+
func->walk([&](cir::ReturnOp op) {
946+
ops.push_back(op.getOperation());
947+
++numReturnOps;
948+
if (!isa<cir::FuncOp>(op->getParentOp()))
949+
hasReturnOpWithFuncOpParentOnly = false;
950+
});
951+
952+
// Skip the unifying if there is only one returnOp and it has the funcOp as
953+
// the direct parent.
954+
if (hasReturnOpWithFuncOpParentOnly && numReturnOps < 2)
955+
return;
956+
957+
bool hasRetVals = (func.getNumResults() > 0);
958+
auto *endBody = &func.getBody().back();
959+
// Create a dedicated return block at the end of the function.
960+
auto *retBlock = endBody->splitBlock(endBody->end());
961+
if (hasRetVals)
962+
retBlock->addArguments(func.getResultTypes(), func.getLoc());
963+
964+
// Rewrite returnOp(s) as branches to that dedicated return block.
965+
RewritePatternSet patterns(&getContext());
966+
patterns.add<UnifyReturn>(patterns.getContext(), func, retBlock);
967+
968+
// Apply patterns.
969+
if (applyOpPatternsGreedily(ops, std::move(patterns)).failed())
970+
signalPassFailure();
971+
972+
// Finally, add returnOp in that dedicated return block.
973+
auto builder = OpBuilder::atBlockBegin(retBlock);
974+
if (hasRetVals)
975+
builder.create<cir::ReturnOp>(func.getLoc(), retBlock->getArguments());
976+
else
977+
builder.create<cir::ReturnOp>(func.getLoc());
978+
}
979+
909980
void populateFlattenCFGPatterns(RewritePatternSet &patterns) {
910981
patterns
911982
.add<CIRIfFlattening, CIRLoopOpInterfaceFlattening, CIRScopeOpFlattening,
@@ -917,6 +988,8 @@ void FlattenCFGPass::runOnOperation() {
917988
RewritePatternSet patterns(&getContext());
918989
populateFlattenCFGPatterns(patterns);
919990

991+
llvm::errs() << "ThroughMLIR: " << (this->throughMLIR ? "YES" : "NO") << '\n';
992+
920993
// Collect operations to apply patterns.
921994
llvm::SmallVector<Operation *, 16> ops;
922995
getOperation()->walk<mlir::WalkOrder::PostOrder>([&](Operation *op) {
@@ -927,6 +1000,11 @@ void FlattenCFGPass::runOnOperation() {
9271000
// Apply patterns.
9281001
if (applyOpPatternsGreedily(ops, std::move(patterns)).failed())
9291002
signalPassFailure();
1003+
1004+
// If CIR is to be lowered into MLIR, unify all 'cir.return's as
1005+
// 'func.return' needs to has 'func.func' as the parent.
1006+
if (throughMLIR)
1007+
getOperation()->walk([&](cir::FuncOp op) { unifyReturn(op); });
9301008
}
9311009

9321010
} // namespace
@@ -937,4 +1015,10 @@ std::unique_ptr<Pass> createFlattenCFGPass() {
9371015
return std::make_unique<FlattenCFGPass>();
9381016
}
9391017

1018+
std::unique_ptr<Pass> createFlattenCFGPass(bool throughMLIR) {
1019+
auto flatten = std::make_unique<FlattenCFGPass>();
1020+
flatten->setThroughMLIR(throughMLIR);
1021+
return std::move(flatten);
1022+
}
1023+
9401024
} // namespace mlir

‎clang/lib/CIR/FrontendAction/CIRGenAction.cpp

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -206,12 +206,16 @@ class CIRGenConsumer : public clang::ASTConsumer {
206206
feOptions.ClangIRCallConvLowering &&
207207
!(action == CIRGenAction::OutputType::EmitMLIR &&
208208
feOptions.MLIRTargetDialect == frontend::MLIR_CIR);
209+
209210
bool flattenCIR =
210211
action == CIRGenAction::OutputType::EmitMLIR &&
211-
feOptions.MLIRTargetDialect == clang::frontend::MLIR_CIR_FLAT;
212+
(feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE_FLAT ||
213+
feOptions.MLIRTargetDialect == clang::frontend::MLIR_CIR_FLAT);
212214

213-
bool emitCore = action == CIRGenAction::OutputType::EmitMLIR &&
214-
feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE;
215+
bool emitCore =
216+
action == CIRGenAction::OutputType::EmitMLIR &&
217+
(feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE ||
218+
feOptions.MLIRTargetDialect == clang::frontend::MLIR_CORE_FLAT);
215219

216220
// Setup and run CIR pipeline.
217221
std::string passOptParsingFailure;
@@ -283,6 +287,7 @@ class CIRGenConsumer : public clang::ASTConsumer {
283287
case CIRGenAction::OutputType::EmitMLIR: {
284288
switch (feOptions.MLIRTargetDialect) {
285289
case clang::frontend::MLIR_CORE:
290+
case clang::frontend::MLIR_CORE_FLAT:
286291
// case for direct lowering is already checked in compiler invocation
287292
// no need to check here
288293
emitMLIR(lowerFromCIRToMLIR(mlirMod, mlirCtx.get()), false);

‎clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4779,7 +4779,7 @@ std::unique_ptr<mlir::Pass> createConvertCIRToLLVMPass() {
47794779
}
47804780

47814781
void populateCIRToLLVMPasses(mlir::OpPassManager &pm, bool useCCLowering) {
4782-
populateCIRPreLoweringPasses(pm, useCCLowering);
4782+
populateCIRPreLoweringPasses(pm, useCCLowering, /*emitCore=*/false);
47834783
pm.addPass(createConvertCIRToLLVMPass());
47844784
}
47854785

‎clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp

Lines changed: 32 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,8 @@ class CIRReturnLowering : public mlir::OpConversionPattern<cir::ReturnOp> {
6969
mlir::LogicalResult
7070
matchAndRewrite(cir::ReturnOp op, OpAdaptor adaptor,
7171
mlir::ConversionPatternRewriter &rewriter) const override {
72+
assert(isa<mlir::FunctionOpInterface>(op->getParentOp()) &&
73+
"'func.return' op expects parent op 'func.func'");
7274
rewriter.replaceOpWithNewOp<mlir::func::ReturnOp>(op,
7375
adaptor.getOperands());
7476
return mlir::LogicalResult::success();
@@ -660,10 +662,13 @@ class CIRFuncOpLowering : public mlir::OpConversionPattern<cir::FuncOp> {
660662
resultType ? mlir::TypeRange(resultType)
661663
: mlir::TypeRange()));
662664

663-
if (failed(rewriter.convertRegionTypes(&op.getBody(), *typeConverter,
664-
&signatureConversion)))
665-
return mlir::failure();
666-
rewriter.inlineRegionBefore(op.getBody(), fn.getBody(), fn.end());
665+
if (!op.getBody().empty()) {
666+
if (failed(rewriter.convertRegionTypes(&op.getBody(), *typeConverter,
667+
&signatureConversion)))
668+
return mlir::failure();
669+
rewriter.inlineRegionBefore(op.getBody(), fn.getBody(), fn.end());
670+
} else
671+
fn.setPrivate();
667672

668673
rewriter.eraseOp(op);
669674
return mlir::LogicalResult::success();
@@ -833,14 +838,15 @@ class CIRCmpOpLowering : public mlir::OpConversionPattern<cir::CmpOp> {
833838
}
834839
};
835840

836-
class CIRBrOpLowering : public mlir::OpRewritePattern<cir::BrOp> {
841+
class CIRBrOpLowering : public mlir::OpConversionPattern<cir::BrOp> {
837842
public:
838-
using OpRewritePattern<cir::BrOp>::OpRewritePattern;
843+
using mlir::OpConversionPattern<cir::BrOp>::OpConversionPattern;
839844

840845
mlir::LogicalResult
841-
matchAndRewrite(cir::BrOp op,
842-
mlir::PatternRewriter &rewriter) const override {
843-
rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(op, op.getDest());
846+
matchAndRewrite(cir::BrOp op, OpAdaptor adaptor,
847+
mlir::ConversionPatternRewriter &rewriter) const override {
848+
rewriter.replaceOpWithNewOp<mlir::cf::BranchOp>(op, op.getDest(),
849+
adaptor.getDestOperands());
844850
return mlir::LogicalResult::success();
845851
}
846852
};
@@ -1354,24 +1360,23 @@ class CIRPtrStrideOpLowering
13541360

13551361
void populateCIRToMLIRConversionPatterns(mlir::RewritePatternSet &patterns,
13561362
mlir::TypeConverter &converter) {
1357-
patterns.add<CIRReturnLowering, CIRBrOpLowering>(patterns.getContext());
1358-
1359-
patterns.add<
1360-
CIRCmpOpLowering, CIRCallOpLowering, CIRUnaryOpLowering, CIRBinOpLowering,
1361-
CIRLoadOpLowering, CIRConstantOpLowering, CIRStoreOpLowering,
1362-
CIRAllocaOpLowering, CIRFuncOpLowering, CIRScopeOpLowering,
1363-
CIRBrCondOpLowering, CIRTernaryOpLowering, CIRYieldOpLowering,
1364-
CIRCosOpLowering, CIRGlobalOpLowering, CIRGetGlobalOpLowering,
1365-
CIRCastOpLowering, CIRPtrStrideOpLowering, CIRSqrtOpLowering,
1366-
CIRCeilOpLowering, CIRExp2OpLowering, CIRExpOpLowering, CIRFAbsOpLowering,
1367-
CIRAbsOpLowering, CIRFloorOpLowering, CIRLog10OpLowering,
1368-
CIRLog2OpLowering, CIRLogOpLowering, CIRRoundOpLowering,
1369-
CIRPtrStrideOpLowering, CIRSinOpLowering, CIRShiftOpLowering,
1370-
CIRBitClzOpLowering, CIRBitCtzOpLowering, CIRBitPopcountOpLowering,
1371-
CIRBitClrsbOpLowering, CIRBitFfsOpLowering, CIRBitParityOpLowering,
1372-
CIRIfOpLowering, CIRVectorCreateLowering, CIRVectorInsertLowering,
1373-
CIRVectorExtractLowering, CIRVectorCmpOpLowering>(converter,
1374-
patterns.getContext());
1363+
patterns.add<CIRBrOpLowering, CIRReturnLowering, CIRCmpOpLowering,
1364+
CIRCallOpLowering, CIRUnaryOpLowering, CIRBinOpLowering,
1365+
CIRLoadOpLowering, CIRConstantOpLowering, CIRStoreOpLowering,
1366+
CIRAllocaOpLowering, CIRFuncOpLowering, CIRScopeOpLowering,
1367+
CIRBrCondOpLowering, CIRTernaryOpLowering, CIRYieldOpLowering,
1368+
CIRCosOpLowering, CIRGlobalOpLowering, CIRGetGlobalOpLowering,
1369+
CIRCastOpLowering, CIRPtrStrideOpLowering, CIRSqrtOpLowering,
1370+
CIRCeilOpLowering, CIRExp2OpLowering, CIRExpOpLowering,
1371+
CIRFAbsOpLowering, CIRAbsOpLowering, CIRFloorOpLowering,
1372+
CIRLog10OpLowering, CIRLog2OpLowering, CIRLogOpLowering,
1373+
CIRRoundOpLowering, CIRPtrStrideOpLowering, CIRSinOpLowering,
1374+
CIRShiftOpLowering, CIRBitClzOpLowering, CIRBitCtzOpLowering,
1375+
CIRBitPopcountOpLowering, CIRBitClrsbOpLowering,
1376+
CIRBitFfsOpLowering, CIRBitParityOpLowering, CIRIfOpLowering,
1377+
CIRVectorCreateLowering, CIRVectorInsertLowering,
1378+
CIRVectorExtractLowering, CIRVectorCmpOpLowering>(
1379+
converter, patterns.getContext());
13751380
}
13761381

13771382
static mlir::TypeConverter prepareTypeConverter() {

0 commit comments

Comments
 (0)