14#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
15#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
16#include "mlir/Dialect/Arith/IR/Arith.h"
17#include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
18#include "mlir/Dialect/DLTI/DLTI.h"
19#include "mlir/Dialect/Index/IR/IndexDialect.h"
20#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
21#include "mlir/Dialect/Math/IR/Math.h"
22#include "mlir/Dialect/Ptr/IR/PtrOps.h"
23#include "mlir/Dialect/UB/IR/UBOps.h"
24#include "mlir/Dialect/Vector/IR/VectorOps.h"
25#include "mlir/IR/Attributes.h"
26#include "mlir/IR/IRMapping.h"
27#include "mlir/IR/PatternMatch.h"
28#include "mlir/Pass/Pass.h"
29#include "mlir/Tools/mlir-translate/MlirTranslateMain.h"
30#include "mlir/Transforms/DialectConversion.h"
33#define GEN_PASS_DEF_AIECORETOSTANDARD
34#include "aie/Dialect/AIE/Transforms/AIEPasses.h.inc"
42static StringRef getArchTargetTriple(AIEArch arch) {
53 llvm::report_fatal_error(
"unsupported arch");
58static LogicalResult checkCoreIntrinsics(Operation *op) {
59 if (!isa<AIE2PSTargetModel>(op->getParentOfType<DeviceOp>().getTargetModel()))
61 return op->emitOpError(
"has no core lowering for AIE2ps");
65 std::tuple<const char *, std::vector<Type>, std::vector<Type>>;
68static auto getAIE1Intrinsics(OpBuilder &builder) {
69 Type int32Type = IntegerType::get(builder.getContext(), 32);
70 Type int128Type = IntegerType::get(builder.getContext(), 128);
71 Type int384Type = IntegerType::get(builder.getContext(), 384);
72 Type floatType = Float32Type::get(builder.getContext());
77 {
"debug_i32", {int32Type}, {}},
78 {
"llvm.aie.event0", {}, {}},
79 {
"llvm.aie.event1", {}, {}},
81 {int32Type, int32Type},
84 {int32Type, int128Type},
87 {int32Type, floatType},
89 {
"llvm.aie.get.ss", {int32Type}, {int32Type}},
93 {
"llvm.aie.get.fss", {int32Type}, {floatType}},
94 {
"llvm.aie.put.mcd", {int384Type}, {}},
95 {
"llvm.aie.get.scd", {}, {int384Type}},
96 {
"llvm.aie.lock.acquire.reg",
97 {int32Type, int32Type},
99 {
"llvm.aie.lock.release.reg",
100 {int32Type, int32Type},
106static auto getAIE2Intrinsics(OpBuilder &builder) {
107 Type int32Type = IntegerType::get(builder.getContext(), 32);
108 Type accType = VectorType::get({16}, int32Type);
110 {
"debug_i32", {int32Type}, {}},
111 {
"llvm.aie2.event", {int32Type}, {}},
112 {
"llvm.aie2.put.ms", {int32Type, int32Type}, {}},
113 {
"llvm.aie2.get.ss", {}, {int32Type, int32Type}},
114 {
"llvm.aie2.mcd.write.vec",
115 {accType, int32Type},
117 {
"llvm.aie2.scd.read.vec",
120 {
"llvm.aie2.acquire",
121 {int32Type, int32Type},
123 {
"llvm.aie2.release",
124 {int32Type, int32Type},
126 {
"llvm.aie2.set.ctrl.reg",
127 {int32Type, int32Type},
133static auto getAIE2pIntrinsics(OpBuilder &builder) {
134 Type int32Type = IntegerType::get(builder.getContext(), 32);
135 Type accType = VectorType::get({16}, int32Type);
137 {
"debug_i32", {int32Type}, {}},
138 {
"llvm.aie2p.event", {int32Type}, {}},
139 {
"llvm.aie2p.put.ms",
140 {int32Type, int32Type},
142 {
"llvm.aie2p.get.ss",
144 {int32Type, int32Type}},
145 {
"llvm.aie2p.mcd.write.vec",
146 {accType, int32Type},
148 {
"llvm.aie2p.scd.read.vec",
151 {
"llvm.aie2p.acquire",
152 {int32Type, int32Type},
154 {
"llvm.aie2p.release",
155 {int32Type, int32Type},
157 {
"llvm.aie2p.set.ctrl.reg",
158 {int32Type, int32Type},
164static void declareAIEIntrinsics(AIEArch arch, OpBuilder &builder) {
165 auto registerIntrinsics = [&builder](
const IntrinsicDecls &functions) {
166 for (
auto &i : functions) {
167 auto [name, argTypes, retTypes] = i;
168 func::FuncOp::create(
169 builder, builder.getUnknownLoc(), name,
170 FunctionType::get(builder.getContext(), argTypes, retTypes))
176 registerIntrinsics(getAIE1Intrinsics(builder));
179 registerIntrinsics(getAIE2Intrinsics(builder));
182 registerIntrinsics(getAIE2pIntrinsics(builder));
184 case AIEArch::AIE2ps:
188 llvm::report_fatal_error(
"unsupported arch");
192template <
typename OpTy>
193static void outlineOps(DeviceOp device) {
194 SmallVector<OpTy, 16> ops;
195 for (
const auto &op : device.getOps<OpTy>())
198 for (
const auto &op : ops)
199 op->moveBefore(device);
205static LogicalResult sinkOutsideValuesIntoCore(CoreOp core) {
206 Region &body = core.getBody();
207 OpBuilder builder = OpBuilder::atBlockBegin(&body.front());
208 DenseMap<Value, Value> copies;
209 WalkResult result = body.walk([&](Operation *op) {
210 for (OpOperand &operand : op->getOpOperands()) {
211 Value value = operand.get();
212 if (body.isAncestor(value.getParentRegion()))
214 Operation *def = value.getDefiningOp();
215 if (!def || !def->hasTrait<OpTrait::ConstantLike>()) {
216 InFlightDiagnostic diag =
217 op->emitOpError(
"uses a value defined outside its aie.core, "
218 "which cannot be outlined");
219 diag.attachNote(value.getLoc()) <<
"value defined here";
220 return WalkResult::interrupt();
222 Value © = copies[value];
224 Operation *clone = builder.clone(*def);
225 builder.setInsertionPointAfter(clone);
226 copy = clone->getResult(cast<OpResult>(value).getResultNumber());
230 return WalkResult::advance();
232 return failure(result.wasInterrupted());
236template <
typename MyAIEOp>
237struct AIEOpRemoval : OpConversionPattern<MyAIEOp> {
238 using OpConversionPattern<MyAIEOp>::OpConversionPattern;
239 using OpAdaptor =
typename MyAIEOp::Adaptor;
242 AIEOpRemoval(MLIRContext *context, ModuleOp &m, PatternBenefit benefit = 1)
243 : OpConversionPattern<MyAIEOp>(context, benefit), module(m) {}
247 ConversionPatternRewriter &rewriter)
const override {
248 rewriter.eraseOp(op);
253struct AIEDebugOpToStdLowering : OpConversionPattern<DebugOp> {
254 using OpConversionPattern::OpConversionPattern;
257 AIEDebugOpToStdLowering(MLIRContext *context, ModuleOp &m,
258 PatternBenefit benefit = 1)
259 : OpConversionPattern(context, benefit), module(m) {}
262 matchAndRewrite(DebugOp op, OpAdaptor adaptor,
263 ConversionPatternRewriter &rewriter)
const override {
264 if (failed(checkCoreIntrinsics(op)))
266 std::string funcName =
"debug_i32";
267 auto func =
module.lookupSymbol<func::FuncOp>(funcName);
269 return op.emitOpError(
"Could not find the intrinsic function ")
271 SmallVector<Value, 1> args;
272 args.push_back(op.getArg());
273 func::CallOp::create(rewriter, op.getLoc(), func, args);
274 rewriter.eraseOp(op);
279struct AIEPutStreamToStdLowering : OpConversionPattern<PutStreamOp> {
280 using OpConversionPattern::OpConversionPattern;
283 AIEPutStreamToStdLowering(MLIRContext *context, ModuleOp &m,
284 PatternBenefit benefit = 1)
285 : OpConversionPattern(context, benefit), module(m) {}
288 matchAndRewrite(PutStreamOp op, OpAdaptor adaptor,
289 ConversionPatternRewriter &rewriter)
const override {
290 if (failed(checkCoreIntrinsics(op)))
292 auto device = op->getParentOfType<DeviceOp>();
293 const auto &targetModel = device.getTargetModel();
294 std::string funcName;
295 if (targetModel.getTargetArch() == AIEArch::AIE1)
296 funcName =
"llvm.aie.put.";
297 else if (targetModel.getTargetArch() == AIEArch::AIE2)
298 funcName =
"llvm.aie2.put.";
300 funcName =
"llvm.aie2p.put.";
302 if (op.isWideStream())
304 else if (op.isFloatStream())
309 auto putMSFunc =
module.lookupSymbol<func::FuncOp>(funcName);
311 return op.emitOpError(
"Could not find the intrinsic function ")
313 SmallVector<Value, 2> args;
314 if (targetModel.getTargetArch() == AIEArch::AIE1) {
315 args.push_back(op.getChannel());
316 args.push_back(op.getStreamValue());
318 args.push_back(op.getStreamValue());
319 args.push_back(arith::ConstantOp::create(
320 rewriter, op.getLoc(), IntegerType::get(rewriter.getContext(), 32),
321 rewriter.getI32IntegerAttr(0)));
323 func::CallOp::create(rewriter, op.getLoc(), putMSFunc, args);
324 rewriter.eraseOp(op);
329struct AIEGetStreamToStdLowering : OpConversionPattern<GetStreamOp> {
330 using OpConversionPattern::OpConversionPattern;
333 AIEGetStreamToStdLowering(MLIRContext *context, ModuleOp &m,
334 PatternBenefit benefit = 1)
335 : OpConversionPattern(context, benefit), module(m) {}
338 matchAndRewrite(GetStreamOp op, OpAdaptor adaptor,
339 ConversionPatternRewriter &rewriter)
const override {
340 if (failed(checkCoreIntrinsics(op)))
342 auto device = op->getParentOfType<DeviceOp>();
343 const auto &targetModel = device.getTargetModel();
344 std::string funcName;
345 if (targetModel.getTargetArch() == AIEArch::AIE1)
346 funcName =
"llvm.aie.get.";
347 else if (targetModel.getTargetArch() == AIEArch::AIE2)
348 funcName =
"llvm.aie2.get.";
350 funcName =
"llvm.aie2p.get.";
352 if (op.isWideStream())
354 else if (op.isFloatStream())
359 auto getSSFunc =
module.lookupSymbol<func::FuncOp>(funcName);
361 return op.emitOpError(
"Could not find the intrinsic function ")
363 SmallVector<Value, 2> args;
364 if (targetModel.getTargetArch() == AIEArch::AIE1)
365 args.push_back(op.getChannel());
367 func::CallOp::create(rewriter, op.getLoc(), getSSFunc, args);
368 rewriter.replaceOp(op, getSSCall.getResult(0));
374struct AIEPutCascadeToStdLowering : OpConversionPattern<PutCascadeOp> {
375 using OpConversionPattern::OpConversionPattern;
378 AIEPutCascadeToStdLowering(MLIRContext *context, ModuleOp &m,
379 PatternBenefit benefit = 1)
380 : OpConversionPattern(context, benefit), module(m) {}
383 matchAndRewrite(PutCascadeOp op, OpAdaptor adaptor,
384 ConversionPatternRewriter &rewriter)
const override {
385 if (failed(checkCoreIntrinsics(op)))
387 auto device = op->getParentOfType<DeviceOp>();
388 const auto &targetModel = device.getTargetModel();
389 std::string funcName;
390 if (targetModel.getTargetArch() == AIEArch::AIE1)
391 funcName =
"llvm.aie.put.mcd";
392 else if (targetModel.getTargetArch() == AIEArch::AIE2)
393 funcName =
"llvm.aie2.mcd.write.vec";
395 funcName =
"llvm.aie2p.mcd.write.vec";
396 auto putMCDFunc =
module.lookupSymbol<func::FuncOp>(funcName);
398 return op.emitOpError(
"Could not find the intrinsic function ")
400 SmallVector<Value, 2> args;
401 Value cascadeValue = op.getCascadeValue();
404 Type expectedInputType = putMCDFunc.getFunctionType().getInput(0);
405 Type actualInputType = cascadeValue.getType();
407 if (expectedInputType != actualInputType) {
410 cascadeValue = vector::BitCastOp::create(rewriter, op.getLoc(),
411 expectedInputType, cascadeValue);
414 args.push_back(cascadeValue);
415 if (isa<AIE2TargetModel>(targetModel))
416 args.push_back(arith::ConstantOp::create(
417 rewriter, op.getLoc(), IntegerType::get(rewriter.getContext(), 32),
418 rewriter.getI32IntegerAttr(1)));
420 func::CallOp::create(rewriter, op.getLoc(), putMCDFunc, args);
421 rewriter.eraseOp(op);
426struct AIEGetCascadeToStdLowering : OpConversionPattern<GetCascadeOp> {
427 using OpConversionPattern::OpConversionPattern;
430 AIEGetCascadeToStdLowering(MLIRContext *context, ModuleOp &m,
431 PatternBenefit benefit = 1)
432 : OpConversionPattern(context, benefit), module(m) {}
435 matchAndRewrite(GetCascadeOp op, OpAdaptor adaptor,
436 ConversionPatternRewriter &rewriter)
const override {
437 if (failed(checkCoreIntrinsics(op)))
439 auto device = op->getParentOfType<DeviceOp>();
440 const auto &targetModel = device.getTargetModel();
441 std::string funcName;
442 if (targetModel.getTargetArch() == AIEArch::AIE1)
443 funcName =
"llvm.aie.get.scd";
444 else if (targetModel.getTargetArch() == AIEArch::AIE2)
445 funcName =
"llvm.aie2.scd.read.vec";
447 funcName =
"llvm.aie2p.scd.read.vec";
448 auto getSCDFunc =
module.lookupSymbol<func::FuncOp>(funcName);
450 return op.emitOpError(
"Could not find the intrinsic function ")
452 SmallVector<Value, 2> args;
453 if (isa<AIE2TargetModel>(targetModel))
454 args.push_back(arith::ConstantOp::create(
455 rewriter, op.getLoc(), IntegerType::get(rewriter.getContext(), 32),
456 rewriter.getI32IntegerAttr(1)));
459 func::CallOp::create(rewriter, op.getLoc(), getSCDFunc, args);
460 Value result = getSCDCall.getResult(0);
463 Type expectedType = op.getResult().getType();
464 Type intrinsicReturnType = result.getType();
466 if (expectedType != intrinsicReturnType) {
469 result = vector::BitCastOp::create(rewriter, op.getLoc(), expectedType,
473 rewriter.replaceOp(op, result);
478struct AIEUseLockToStdLowering : OpConversionPattern<UseLockOp> {
479 using OpConversionPattern::OpConversionPattern;
482 AIEUseLockToStdLowering(MLIRContext *context, ModuleOp &m,
483 PatternBenefit benefit = 1)
484 : OpConversionPattern(context, benefit), module(m) {}
486 matchAndRewrite(UseLockOp useLock, OpAdaptor adaptor,
487 ConversionPatternRewriter &rewriter)
const override {
488 if (!isa<DeviceOp>(useLock->getParentOp())) {
489 auto device = useLock->getParentOfType<DeviceOp>();
491 return module.emitOpError("Device Not found!");
493 const auto &targetModel = device.getTargetModel();
497 if (isa<AIE2PSTargetModel>(targetModel)) {
498 if (useLock->getParentOfType<CoreOp>() ||
499 useLock->getParentOfType<func::FuncOp>())
500 return checkCoreIntrinsics(useLock);
501 rewriter.eraseOp(useLock);
506 std::string funcName;
507 if (targetModel.getTargetArch() == AIEArch::AIE1)
508 funcName =
"llvm.aie.lock.";
509 else if (targetModel.getTargetArch() == AIEArch::AIE2)
510 funcName =
"llvm.aie2.";
512 funcName =
"llvm.aie2p.";
513 if (useLock.acquire() || useLock.acquireGE())
514 funcName +=
"acquire";
515 else if (useLock.release())
516 funcName +=
"release";
517 if (targetModel.getTargetArch() == AIEArch::AIE1)
520 auto useLockFunc =
module.lookupSymbol<func::FuncOp>(funcName);
522 return useLock.emitOpError(
"Could not find the intrinsic function!");
524 SmallVector<Value, 2> args;
525 auto i32Ty = IntegerType::get(rewriter.getContext(), 32);
526 args.push_back(arith::IndexCastOp::create(rewriter, useLock.getLoc(),
527 i32Ty, useLock.getLock()));
529 Value value = adaptor.getValue();
532 if (useLock.acquireGE()) {
533 Value zero = arith::ConstantOp::create(
534 rewriter, useLock.getLoc(), i32Ty, rewriter.getI32IntegerAttr(0));
535 value = arith::SubIOp::create(rewriter, useLock.getLoc(), zero, value);
537 args.push_back(value);
539 func::CallOp::create(rewriter, useLock.getLoc(), useLockFunc, args);
541 rewriter.eraseOp(useLock);
546struct AIEBufferToStandard : OpConversionPattern<BufferOp> {
547 using OpConversionPattern::OpConversionPattern;
549 AIEBufferToStandard(MLIRContext *context, ModuleOp &m,
550 PatternBenefit benefit = 1)
551 : OpConversionPattern(context, benefit), module(m) {}
553 matchAndRewrite(BufferOp buffer, OpAdaptor adaptor,
554 ConversionPatternRewriter &rewriter)
const override {
556 if (buffer.getCoreData()) {
557 rewriter.eraseOp(buffer);
560 rewriter.setInsertionPointToStart(module.getBody());
561 auto t = llvm::cast<MemRefType>(buffer.getType());
562 auto symName = buffer.name().getValue();
570 memref::GlobalOp::create(rewriter, buffer.getLoc(), symName,
571 rewriter.getStringAttr(
"public"), buffer.getType(),
575 for (
auto &use : make_early_inc_range(buffer.getResult().getUses())) {
576 Operation *user = use.getOwner();
577 rewriter.setInsertionPoint(user);
579 memref::GetGlobalOp::create(rewriter, buffer.getLoc(), t, symName);
581 memref::AssumeAlignmentOp::create(rewriter, buffer.getLoc(), allocated,
584 use.set(allocated.getResult());
587 rewriter.eraseOp(buffer);
592struct AIECoreToStandardFunc : OpConversionPattern<CoreOp> {
593 using OpConversionPattern::OpConversionPattern;
596 DenseMap<Operation *, SmallVector<BufferOp, 4>> &tileToBuffers;
600 AIECoreToStandardFunc(
601 MLIRContext *context, ModuleOp &m, IRMapping &mapper,
602 DenseMap<Operation *, SmallVector<BufferOp, 4>> &tileToBuffers,
603 PatternBenefit benefit = 1,
int tileCol = 1,
int tileRow = 1)
604 : OpConversionPattern(context, benefit), module(m), mapper(mapper),
605 tileToBuffers(tileToBuffers), tileCol(tileCol), tileRow(tileRow) {}
608 matchAndRewrite(CoreOp op, OpAdaptor adaptor,
609 ConversionPatternRewriter &rewriter)
const override {
611 int col = op.colIndex();
612 int row = op.rowIndex();
615 if ((tileRow != row && tileRow != -1) ||
616 (tileCol != col && tileCol != -1)) {
617 rewriter.eraseOp(op);
622 rewriter.setInsertionPointAfter(op->getParentOp());
626 func::FuncOp::create(rewriter, op.getLoc(), coreName,
627 FunctionType::get(rewriter.getContext(), {}, {}));
629 rewriter.cloneRegionBefore(op.getBody(), coreFunc.getBody(),
630 coreFunc.getBody().begin(), mapper);
637 bool hasIntegerSRS =
false;
638 bool hasBF16Matmul =
false;
639 auto scan = [&](Operation *childOp) {
640 StringRef opName = childOp->getName().getStringRef();
641 if (opName ==
"aievec.srs") {
646 if (childOp->getNumResults() > 0) {
647 auto resultType = childOp->getResult(0).getType();
648 if (
auto vecType = dyn_cast<VectorType>(resultType)) {
649 if (vecType.getElementType().isInteger())
650 hasIntegerSRS =
true;
658 if (opName ==
"aievec.to_bfp16" || opName ==
"aievec.matmul_aie2p_bfp16")
659 hasBF16Matmul =
true;
660 if (opName ==
"aievec.matmul" || opName ==
"aievec.matmul_aie2p") {
661 if (childOp->getNumOperands() > 0) {
662 auto lhsType = childOp->getOperand(0).getType();
663 if (
auto vecType = dyn_cast<VectorType>(lhsType))
664 if (vecType.getElementType().isBF16())
665 hasBF16Matmul =
true;
670 auto device = op->getParentOfType<DeviceOp>();
673 if (device && isa<AIE2PSTargetModel>(device.getTargetModel())) {
674 SmallVector<func::FuncOp> worklist;
675 DenseSet<Operation *> visited;
676 auto addCallees = [&](Operation *root) {
677 root->walk([&](func::CallOp call) {
678 auto callee = SymbolTable::lookupNearestSymbolFrom<func::FuncOp>(
679 device, call.getCalleeAttr());
680 if (callee && visited.insert(callee).second)
681 worklist.push_back(callee);
684 addCallees(coreFunc);
685 while (!worklist.empty()) {
686 func::FuncOp callee = worklist.pop_back_val();
691 if (hasSRS || hasBF16Matmul) {
693 if (isa<AIE2PSTargetModel>(device.getTargetModel()))
694 return op.emitOpError(
"needs the rounding and saturation modes set "
695 "for aievec.srs or bf16 matmul, which has no "
696 "lowering for AIE2ps");
697 AIEArch arch = device.getTargetModel().getTargetArch();
698 if (arch == AIEArch::AIE2 || arch == AIEArch::AIE2p) {
699 std::string ctrlRegFuncName = (arch == AIEArch::AIE2p)
700 ?
"llvm.aie2p.set.ctrl.reg"
701 :
"llvm.aie2.set.ctrl.reg";
702 auto ctrlRegFunc =
module.lookupSymbol<func::FuncOp>(ctrlRegFuncName);
704 Block &entryBlock = coreFunc.getBody().front();
705 rewriter.setInsertionPointToStart(&entryBlock);
706 Location loc = op.getLoc();
716 int rndRegIdx = (arch == AIEArch::AIE2p) ? 1 : 6;
718 auto cSatIdx = arith::ConstantOp::create(
719 rewriter, loc, rewriter.getI32IntegerAttr(satRegIdx));
720 auto c1 = arith::ConstantOp::create(rewriter, loc,
721 rewriter.getI32IntegerAttr(1));
722 func::CallOp::create(rewriter, loc, ctrlRegFunc,
723 ValueRange{cSatIdx, c1});
734 int roundingMode = hasIntegerSRS && !hasBF16Matmul ? 9 : 12;
735 auto cRndIdx = arith::ConstantOp::create(
736 rewriter, loc, rewriter.getI32IntegerAttr(rndRegIdx));
737 auto cRoundingMode = arith::ConstantOp::create(
738 rewriter, loc, rewriter.getI32IntegerAttr(roundingMode));
739 func::CallOp::create(rewriter, loc, ctrlRegFunc,
740 ValueRange{cRndIdx, cRoundingMode});
747 coreFunc.getBody().walk([&](Operation *childOp) {
748 rewriter.setInsertionPointAfter(childOp);
750 if (isa<EndOp>(childOp)) {
751 func::ReturnOp::create(rewriter, childOp->getLoc(), ValueRange({}));
752 rewriter.eraseOp(childOp);
756 rewriter.eraseOp(op);
762struct AIEEventOpToStdLowering : OpConversionPattern<EventOp> {
763 using OpConversionPattern::OpConversionPattern;
766 AIEEventOpToStdLowering(MLIRContext *context, ModuleOp &m,
767 PatternBenefit benefit = 1)
768 : OpConversionPattern(context, benefit), module(m) {}
771 matchAndRewrite(EventOp op, OpAdaptor adaptor,
772 ConversionPatternRewriter &rewriter)
const override {
773 auto device = op->getParentOfType<DeviceOp>();
774 std::string funcName;
775 SmallVector<Value, 1> args;
776 switch (device.getTargetModel().getTargetArch()) {
778 funcName =
"llvm.aie.event" + std::to_string(op.getVal());
781 funcName =
"llvm.aie2.event";
782 args.push_back(arith::ConstantOp::create(
783 rewriter, op.getLoc(), rewriter.getI32Type(),
784 rewriter.getI32IntegerAttr(op.getVal())));
787 funcName =
"llvm.aie2p.event";
788 args.push_back(arith::ConstantOp::create(
789 rewriter, op.getLoc(), rewriter.getI32Type(),
790 rewriter.getI32IntegerAttr(op.getVal())));
792 case AIEArch::AIE2ps:
793 return op.emitOpError(
"has no core lowering for AIE2ps");
795 auto eventFunc =
module.lookupSymbol<func::FuncOp>(funcName);
797 return op.emitOpError(
"Could not find the intrinsic function ")
799 func::CallOp::create(rewriter, op.getLoc(), eventFunc, args);
800 rewriter.eraseOp(op);
805struct AIECoreToStandardPass
806 : xilinx::AIE::impl::AIECoreToStandardBase<AIECoreToStandardPass> {
807 AIECoreToStandardPass() =
default;
808 AIECoreToStandardPass(
const AIECoreToStandardOptions &options) {
809 deviceName = options.deviceName;
810 tileCol = options.tileCol;
811 tileRow = options.tileRow;
814 void runOnOperation()
override {
816 ModuleOp m = getOperation();
817 OpBuilder builder = OpBuilder::atBlockEnd(m.getBody());
819 DeviceOp deviceOp = DeviceOp::getForSymbolInModuleOrError(m, deviceName);
821 return signalPassFailure();
823 const auto &targetModel = deviceOp.getTargetModel();
826 if (
auto dlAttr = deviceOp->getAttr(DLTIDialect::kDataLayoutAttrName)) {
827 m->setAttr(DLTIDialect::kDataLayoutAttrName, dlAttr);
832 m->setAttr(LLVM::LLVMDialect::getTargetTripleAttrName(),
833 builder.getStringAttr(
834 getArchTargetTriple(targetModel.getTargetArch())));
836 DenseMap<Operation *, SmallVector<BufferOp, 4>> tileToBuffers;
842 builder.setInsertionPointToStart(m.getBody());
843 declareAIEIntrinsics(targetModel.getTargetArch(), builder);
846 ConversionTarget target(getContext());
847 target.addLegalDialect<func::FuncDialect>();
848 target.addLegalDialect<cf::ControlFlowDialect>();
849 target.addLegalDialect<memref::MemRefDialect>();
850 target.addLegalDialect<VectorDialect>();
851 target.addLegalDialect<aievec::AIEVecDialect>();
852 target.addLegalDialect<arith::ArithDialect>();
853 target.addLegalDialect<ub::UBDialect>();
854 target.addLegalDialect<math::MathDialect>();
855 target.addLegalDialect<index::IndexDialect>();
856 target.addLegalDialect<ptr::PtrDialect>();
859 target.addLegalDialect<LLVM::LLVMDialect>();
860 target.addLegalOp<func::FuncOp, ModuleOp, UnrealizedConversionCastOp>();
864 target.addIllegalOp<BufferOp>();
865 target.addDynamicallyLegalOp<PutStreamOp, GetStreamOp, PutCascadeOp,
866 GetCascadeOp, DebugOp, UseLockOp, EventOp>(
867 [col =
static_cast<int>(tileCol),
868 row =
static_cast<int>(tileRow)](Operation *op) {
869 auto core = op->getParentOfType<CoreOp>();
870 return core && ((row != core.rowIndex() && row != -1) ||
871 (col != core.colIndex() && col != -1));
874 RewritePatternSet patterns(&getContext());
875 patterns.add<AIEPutStreamToStdLowering, AIEGetStreamToStdLowering,
876 AIEPutCascadeToStdLowering, AIEGetCascadeToStdLowering,
877 AIEDebugOpToStdLowering, AIEUseLockToStdLowering,
878 AIEEventOpToStdLowering>(m.getContext(), m);
880 patterns.add<AIEBufferToStandard>(m.getContext(), m, 1);
881 if (failed(applyPartialConversion(deviceOp, target, std::move(patterns))))
882 return signalPassFailure();
885 int col =
static_cast<int>(tileCol);
886 int row =
static_cast<int>(tileRow);
887 for (CoreOp core : deviceOp.getOps<CoreOp>()) {
888 if ((row != core.rowIndex() && row != -1) ||
889 (col != core.colIndex() && col != -1))
891 if (failed(sinkOutsideValuesIntoCore(core)))
892 return signalPassFailure();
895 RewritePatternSet outlinePatterns(&getContext());
896 outlinePatterns.add<AIECoreToStandardFunc>(m.getContext(), m, mapper,
900 target.addIllegalOp<CoreOp>();
901 if (failed(applyPartialConversion(deviceOp, target,
902 std::move(outlinePatterns))))
903 return signalPassFailure();
907 outlineOps<memref::GlobalOp>(deviceOp);
908 outlineOps<func::FuncOp>(deviceOp);
910 RewritePatternSet removepatterns(&getContext());
912 AIEOpRemoval<DeviceOp>, AIEOpRemoval<TileOp>, AIEOpRemoval<FlowOp>,
913 AIEOpRemoval<MemOp>, AIEOpRemoval<ShimDMAOp>, AIEOpRemoval<ShimMuxOp>,
914 AIEOpRemoval<SwitchboxOp>, AIEOpRemoval<LockOp>, AIEOpRemoval<BufferOp>,
915 AIEOpRemoval<ExternalBufferOp>, AIEOpRemoval<ShimDMAAllocationOp>,
916 AIEOpRemoval<CascadeFlowOp>, AIEOpRemoval<ConfigureCascadeOp>>(
919 if (failed(applyPartialConversion(m, target, std::move(removepatterns))))
920 return signalPassFailure();
926 return std::make_unique<AIECoreToStandardPass>();
929std::unique_ptr<OperationPass<ModuleOp>>
931 return std::make_unique<AIECoreToStandardPass>(options);
std::tuple< const char *, std::vector< Type >, std::vector< Type > > IntrinsicDecl
std::vector< IntrinsicDecl > IntrinsicDecls
std::string coreFrameSymbolName(int col, int row)
std::unique_ptr< mlir::OperationPass< mlir::ModuleOp > > createAIECoreToStandardPass()
AIEOpRemoval(MLIRContext *context, PatternBenefit benefit=1)
LogicalResult matchAndRewrite(MyOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override