From c53151eee8a380318d70bd688e4be0604d89ae31 Mon Sep 17 00:00:00 2001 From: xlauko Date: Sun, 2 Nov 2025 12:57:58 +0100 Subject: [PATCH] [CIR] Use free op create functions (NFC) The builder create methods are deprecated: https://mlir.llvm.org/deprecation/. See https://discourse.llvm.org/t/psa-opty-create-now-with-100-more-tab-complete/87339. --- clang/lib/CIR/CodeGen/CIRAsm.cpp | 6 +- clang/lib/CIR/CodeGen/CIRGenAtomic.cpp | 30 +- clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp | 108 +-- .../lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp | 150 ++-- clang/lib/CIR/CodeGen/CIRGenBuiltinNVPTX.cpp | 89 +-- clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp | 182 +++-- clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp | 6 +- clang/lib/CIR/CodeGen/CIRGenCUDARuntime.cpp | 4 +- clang/lib/CIR/CodeGen/CIRGenCXX.cpp | 6 +- clang/lib/CIR/CodeGen/CIRGenCall.cpp | 10 +- clang/lib/CIR/CodeGen/CIRGenClass.cpp | 21 +- clang/lib/CIR/CodeGen/CIRGenCleanup.cpp | 12 +- clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp | 35 +- clang/lib/CIR/CodeGen/CIRGenDecl.cpp | 11 +- clang/lib/CIR/CodeGen/CIRGenException.cpp | 21 +- clang/lib/CIR/CodeGen/CIRGenExpr.cpp | 163 ++-- clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp | 34 +- clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp | 18 +- clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp | 33 +- clang/lib/CIR/CodeGen/CIRGenExprConst.cpp | 15 +- clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp | 295 +++---- clang/lib/CIR/CodeGen/CIRGenFunction.cpp | 30 +- clang/lib/CIR/CodeGen/CIRGenFunction.h | 5 +- clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp | 120 ++- clang/lib/CIR/CodeGen/CIRGenModule.cpp | 12 +- clang/lib/CIR/CodeGen/CIRGenOpenMPRuntime.cpp | 6 +- clang/lib/CIR/CodeGen/CIRGenStmt.cpp | 112 +-- clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp | 8 +- clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 31 +- clang/lib/CIR/Dialect/IR/CIRMemorySlot.cpp | 14 +- .../Dialect/Transforms/CIRCanonicalize.cpp | 6 +- .../Dialect/Transforms/CallConvLowering.cpp | 2 +- .../lib/CIR/Dialect/Transforms/FlattenCFG.cpp | 84 +- .../lib/CIR/Dialect/Transforms/GotoSolver.cpp | 2 +- .../CIR/Dialect/Transforms/HoistAllocas.cpp | 2 +- .../Dialect/Transforms/IdiomRecognizer.cpp | 17 +- clang/lib/CIR/Dialect/Transforms/LibOpt.cpp | 37 +- .../Dialect/Transforms/LoweringPrepare.cpp | 130 ++-- .../lib/CIR/Dialect/Transforms/SCFPrepare.cpp | 4 +- .../Transforms/TargetLowering/ABIInfoImpl.cpp | 4 +- .../TargetLowering/ItaniumCXXABI.cpp | 192 ++--- .../TargetLowering/LowerFunction.cpp | 130 ++-- .../Targets/LoweringPrepareAArch64CXXABI.cpp | 72 +- .../Targets/LoweringPrepareItaniumCXXABI.cpp | 47 +- .../Targets/LoweringPrepareX86CXXABI.cpp | 12 +- .../CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 731 +++++++++--------- .../Lowering/DirectToLLVM/LoweringHelpers.h | 20 +- .../ThroughMLIR/LowerCIRLoopToSCF.cpp | 21 +- .../Lowering/ThroughMLIR/LowerCIRToMLIR.cpp | 196 ++--- .../Lowering/ThroughMLIR/LowerToMLIRHelpers.h | 16 +- 50 files changed, 1673 insertions(+), 1639 deletions(-) diff --git a/clang/lib/CIR/CodeGen/CIRAsm.cpp b/clang/lib/CIR/CodeGen/CIRAsm.cpp index f8b45c010a16..aa12060b88e8 100644 --- a/clang/lib/CIR/CodeGen/CIRAsm.cpp +++ b/clang/lib/CIR/CodeGen/CIRAsm.cpp @@ -620,9 +620,9 @@ mlir::LogicalResult CIRGenFunction::emitAsmStmt(const AsmStmt &S) { operands.push_back(InArgs); operands.push_back(InOutArgs); - auto IA = builder.create( - getLoc(S.getAsmLoc()), ResultType, operands, AsmString, Constraints, - HasSideEffect, inferFlavor(CGM, S), mlir::ArrayAttr()); + auto IA = cir::InlineAsmOp::create( + builder, getLoc(S.getAsmLoc()), ResultType, operands, AsmString, + Constraints, HasSideEffect, inferFlavor(CGM, S), mlir::ArrayAttr()); if (false /*IsGCCAsmGoto*/) { assert(!cir::MissingFeatures::asmGoto()); diff --git a/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp b/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp index 20bde84d1395..54fd8b5219d8 100644 --- a/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenAtomic.cpp @@ -378,8 +378,8 @@ static bool isCstWeak(mlir::Value weakVal, bool &val) { static void emitDefaultCase(CIRGenBuilderTy &builder, mlir::Location loc) { auto EmptyArrayAttr = builder.getArrayAttr({}); mlir::OpBuilder::InsertPoint insertPoint; - builder.create(loc, EmptyArrayAttr, cir::CaseOpKind::Default, - insertPoint); + cir::CaseOp::create(builder, loc, EmptyArrayAttr, cir::CaseOpKind::Default, + insertPoint); builder.restoreInsertionPoint(insertPoint); } @@ -392,8 +392,8 @@ static void emitSingleMemOrderCase(CIRGenBuilderTy &builder, mlir::Location loc, cir::IntAttr::get(Type, static_cast(Order))}; auto OneAttribute = builder.getArrayAttr(OneOrder); mlir::OpBuilder::InsertPoint insertPoint; - builder.create(loc, OneAttribute, cir::CaseOpKind::Equal, - insertPoint); + cir::CaseOp::create(builder, loc, OneAttribute, cir::CaseOpKind::Equal, + insertPoint); builder.restoreInsertionPoint(insertPoint); } @@ -408,8 +408,8 @@ static void emitDoubleMemOrderCase(CIRGenBuilderTy &builder, mlir::Location loc, cir::IntAttr::get(Type, static_cast(Order2))}; auto TwoAttributes = builder.getArrayAttr(TwoOrders); mlir::OpBuilder::InsertPoint insertPoint; - builder.create(loc, TwoAttributes, cir::CaseOpKind::Anyof, - insertPoint); + cir::CaseOp::create(builder, loc, TwoAttributes, cir::CaseOpKind::Anyof, + insertPoint); builder.restoreInsertionPoint(insertPoint); } @@ -424,9 +424,9 @@ static void emitAtomicCmpXchg(CIRGenFunction &CGF, AtomicExpr *E, bool IsWeak, auto Expected = builder.createLoad(loc, Val1); auto Desired = builder.createLoad(loc, Val2); auto boolTy = builder.getBoolTy(); - auto cmpxchg = builder.create( - loc, Expected.getType(), boolTy, Ptr.getPointer(), Expected, Desired, - cir::MemOrderAttr::get(&CGF.getMLIRContext(), SuccessOrder), + auto cmpxchg = cir::AtomicCmpXchg::create( + builder, loc, Expected.getType(), boolTy, Ptr.getPointer(), Expected, + Desired, cir::MemOrderAttr::get(&CGF.getMLIRContext(), SuccessOrder), cir::MemOrderAttr::get(&CGF.getMLIRContext(), FailureOrder), cir::MemScopeKindAttr::get(&CGF.getMLIRContext(), Scope), builder.getI64IntegerAttr(Ptr.getAlignment().getAsAlign().value())); @@ -434,8 +434,8 @@ static void emitAtomicCmpXchg(CIRGenFunction &CGF, AtomicExpr *E, bool IsWeak, cmpxchg.setWeak(IsWeak); auto cmp = builder.createNot(cmpxchg.getCmp()); - builder.create( - loc, cmp, false, [&](mlir::OpBuilder &, mlir::Location) { + cir::IfOp::create( + builder, loc, cmp, false, [&](mlir::OpBuilder &, mlir::Location) { auto ptrTy = mlir::cast(Val1.getPointer().getType()); if (Val1.getElementType() != ptrTy.getPointee()) { Val1 = Val1.withPointer(builder.createPtrBitcast( @@ -496,8 +496,8 @@ static void emitAtomicCmpXchgFailureSet( // can't handle a runtime value; all memory orders must be hard coded. // Generate a "switch" statement that converts the runtime value into a // compile-time value. - CGF.getBuilder().create( - FailureOrderVal.getLoc(), FailureOrderVal, + cir::SwitchOp::create( + CGF.getBuilder(), FailureOrderVal.getLoc(), FailureOrderVal, [&](mlir::OpBuilder &b, mlir::Location loc, mlir::OperationState &os) { auto &builder = CGF.getBuilder(); @@ -1268,8 +1268,8 @@ RValue CIRGenFunction::emitAtomicExpr(AtomicExpr *E) { // can't handle runtime memory orders; the memory order must be hard coded. // Generate a "switch" statement that converts a runtime value into a // compile-time value. - builder.create( - Order.getLoc(), Order, + cir::SwitchOp::create( + builder, Order.getLoc(), Order, [&](mlir::OpBuilder &b, mlir::Location loc, mlir::OperationState &os) { mlir::Block *switchBlock = builder.getBlock(); diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index 62520ca17107..a32299be814d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp @@ -72,7 +72,7 @@ static RValue emitUnaryMaybeConstrainedFPBuiltin(CIRGenFunction &CGF, llvm_unreachable("constraint FP operations are NYI"); auto Call = - CGF.getBuilder().create(Arg.getLoc(), Arg.getType(), Arg); + Operation::create(CGF.getBuilder(), Arg.getLoc(), Arg.getType(), Arg); return RValue::get(Call->getResult(0)); } @@ -80,7 +80,7 @@ template static RValue emitUnaryFPBuiltin(CIRGenFunction &CGF, const CallExpr &E) { auto Arg = CGF.emitScalarExpr(E.getArg(0)); auto Call = - CGF.getBuilder().create(Arg.getLoc(), Arg.getType(), Arg); + Operation::create(CGF.getBuilder(), Arg.getLoc(), Arg.getType(), Arg); return RValue::get(Call->getResult(0)); } @@ -93,7 +93,7 @@ static RValue emitUnaryMaybeConstrainedFPToIntBuiltin(CIRGenFunction &CGF, if (CGF.getBuilder().getIsFPConstrained()) llvm_unreachable("constraint FP operations are NYI"); - auto Call = CGF.getBuilder().create(Src.getLoc(), ResultType, Src); + auto Call = Op::create(CGF.getBuilder(), Src.getLoc(), ResultType, Src); return RValue::get(Call->getResult(0)); } @@ -104,7 +104,7 @@ static RValue emitBinaryFPBuiltin(CIRGenFunction &CGF, const CallExpr &E) { auto Loc = CGF.getLoc(E.getExprLoc()); auto Ty = CGF.convertType(E.getType()); - auto Call = CGF.getBuilder().create(Loc, Ty, Arg0, Arg1); + auto Call = Op::create(CGF.getBuilder(), Loc, Ty, Arg0, Arg1); return RValue::get(Call->getResult(0)); } @@ -122,7 +122,7 @@ static mlir::Value emitBinaryMaybeConstrainedFPBuiltin(CIRGenFunction &CGF, CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(CGF, &E); llvm_unreachable("constrained FP operations are NYI"); } else { - auto Call = CGF.getBuilder().create(Loc, Ty, Arg0, Arg1); + auto Call = Op::create(CGF.getBuilder(), Loc, Ty, Arg0, Arg1); return Call->getResult(0); } } @@ -141,10 +141,10 @@ static RValue emitBuiltinBitOp( Op op; if constexpr (std::is_same_v || std::is_same_v) { - op = CGF.getBuilder().create(CGF.getLoc(E->getExprLoc()), arg, - isZeroPoison); + op = Op::create(CGF.getBuilder(), CGF.getLoc(E->getExprLoc()), arg, + isZeroPoison); } else { - op = CGF.getBuilder().create(CGF.getLoc(E->getExprLoc()), arg); + op = Op::create(CGF.getBuilder(), CGF.getLoc(E->getExprLoc()), arg); } const mlir::Value result = op.getResult(); if (const mlir::Type resultType = CGF.convertType(E->getType()); @@ -299,10 +299,10 @@ static mlir::Value makeBinaryAtomicValue( *neededValP = val; *neededValT = valueType; } - auto rmwi = builder.create( - cgf.getLoc(expr->getSourceRange()), destAddr.emitRawPointer(), val, kind, - ordering, false, /* is volatile */ - true); /* fetch first */ + auto rmwi = cir::AtomicFetch::create( + builder, cgf.getLoc(expr->getSourceRange()), destAddr.emitRawPointer(), + val, kind, ordering, false, /* is volatile */ + true); /* fetch first */ return emitFromInt(cgf, rmwi->getResult(0), typ, valueType); } @@ -339,10 +339,10 @@ static RValue emitBinaryAtomicPost(CIRGenFunction &cgf, mlir::Value result = makeBinaryAtomicValue(cgf, atomicOpkind, e, &val, &valueType); clang::CIRGen::CIRGenBuilderTy &builder = cgf.getBuilder(); - result = builder.create(result.getLoc(), binopKind, result, val); + result = cir::BinOp::create(builder, result.getLoc(), binopKind, result, val); if (invert) - result = builder.create(result.getLoc(), - cir::UnaryOpKind::Not, result); + result = cir::UnaryOp::create(builder, result.getLoc(), + cir::UnaryOpKind::Not, result); result = emitFromInt(cgf, result, typ, valueType); return RValue::get(result); } @@ -363,9 +363,9 @@ static mlir::Value makeAtomicCmpXchgValue(CIRGenFunction &cgf, auto newVal = emitToInt(cgf, cgf.emitScalarExpr(expr->getArg(2)), typ, intType); - auto op = builder.create( - cgf.getLoc(expr->getSourceRange()), cmpVal.getType(), builder.getBoolTy(), - destAddr.getPointer(), cmpVal, newVal, + auto op = cir::AtomicCmpXchg::create( + builder, cgf.getLoc(expr->getSourceRange()), cmpVal.getType(), + builder.getBoolTy(), destAddr.getPointer(), cmpVal, newVal, MemOrderAttr::get(&cgf.getMLIRContext(), cir::MemOrder::SequentiallyConsistent), MemOrderAttr::get(&cgf.getMLIRContext(), @@ -390,8 +390,8 @@ static mlir::Value makeAtomicFenceValue(CIRGenFunction &cgf, cir::MemOrder ordering = static_cast(constOrderingAttr.getUInt()); - builder.create( - cgf.getLoc(expr->getSourceRange()), ordering, + cir::AtomicFence::create( + builder, cgf.getLoc(expr->getSourceRange()), ordering, MemScopeKindAttr::get(&cgf.getMLIRContext(), syncScope)); } @@ -1163,7 +1163,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, case Builtin::BI__builtin_va_copy: { auto dstPtr = emitVAListRef(E->getArg(0)).getPointer(); auto srcPtr = emitVAListRef(E->getArg(1)).getPointer(); - builder.create(dstPtr.getLoc(), dstPtr, srcPtr); + cir::VACopyOp::create(builder, dstPtr.getLoc(), dstPtr, srcPtr); return {}; } @@ -1178,15 +1178,15 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, mlir::Value Result; switch (getLangOpts().getSignedOverflowBehavior()) { case LangOptions::SOB_Defined: { - auto Call = getBuilder().create(getLoc(E->getExprLoc()), - Arg.getType(), Arg, false); + auto Call = cir::AbsOp::create(getBuilder(), getLoc(E->getExprLoc()), + Arg.getType(), Arg, false); Result = Call->getResult(0); break; } case LangOptions::SOB_Undefined: { if (!SanitizeOverflow) { - auto Call = getBuilder().create(getLoc(E->getExprLoc()), - Arg.getType(), Arg, true); + auto Call = cir::AbsOp::create(getBuilder(), getLoc(E->getExprLoc()), + Arg.getType(), Arg, true); Result = Call->getResult(0); break; } @@ -1328,9 +1328,9 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, Probability); } - auto result = builder.create(getLoc(E->getSourceRange()), - ArgValue.getType(), ArgValue, - ExpectedValue, ProbAttr); + auto result = cir::ExpectOp::create(builder, getLoc(E->getSourceRange()), + ArgValue.getType(), ArgValue, + ExpectedValue, ProbAttr); return RValue::get(result); } @@ -1357,7 +1357,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, return RValue::get(nullptr); mlir::Value argValue = emitCheckedArgForAssume(E->getArg(0)); - builder.create(getLoc(E->getExprLoc()), argValue); + cir::AssumeOp::create(builder, getLoc(E->getExprLoc()), argValue); return RValue::get(nullptr); } @@ -1368,8 +1368,8 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, mlir::Value value0 = emitScalarExpr(arg0); mlir::Value value1 = emitScalarExpr(arg1); - builder.create(getLoc(E->getExprLoc()), value0, - value1); + cir::AssumeSepStorageOp::create(builder, getLoc(E->getExprLoc()), value0, + value1); return RValue::get(nullptr); } @@ -1387,7 +1387,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, case Builtin::BI_byteswap_uint64: { auto arg = emitScalarExpr(E->getArg(0)); return RValue::get( - builder.create(getLoc(E->getSourceRange()), arg)); + cir::ByteswapOp::create(builder, getLoc(E->getSourceRange()), arg)); } case Builtin::BI__builtin_bitreverse8: @@ -1396,7 +1396,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, case Builtin::BI__builtin_bitreverse64: { mlir::Value arg = emitScalarExpr(E->getArg(0)); return RValue::get( - builder.create(getLoc(E->getSourceRange()), arg)); + cir::BitReverseOp::create(builder, getLoc(E->getSourceRange()), arg)); } case Builtin::BI__builtin_rotateleft8: @@ -1450,8 +1450,8 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, ArgType = CGM.getASTContext().getObjCIdType(); ArgValue = builder.createBitcast(ArgValue, convertType(ArgType)); - mlir::Value Result = builder.create( - getLoc(E->getSourceRange()), ArgValue); + mlir::Value Result = cir::IsConstantOp::create( + builder, getLoc(E->getSourceRange()), ArgValue); if (Result.getType() != ResultType) Result = builder.createBoolToInt(Result, ResultType); return RValue::get(Result); @@ -1492,8 +1492,8 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, Locality = evaluateOperandAsInt(E->getArg(2)); mlir::Value Address = emitScalarExpr(E->getArg(0)); - builder.create(getLoc(E->getSourceRange()), Address, - Locality, IsWrite); + cir::PrefetchOp::create(builder, getLoc(E->getSourceRange()), Address, + Locality, IsWrite); return RValue::get(nullptr); } case Builtin::BI__builtin_readcyclecounter: @@ -1507,11 +1507,11 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, builder.createPtrBitcast(emitScalarExpr(E->getArg(0)), voidTy); mlir::Value end = builder.createPtrBitcast(emitScalarExpr(E->getArg(1)), voidTy); - builder.create(getLoc(E->getSourceRange()), begin, end); + cir::ClearCacheOp::create(builder, getLoc(E->getSourceRange()), begin, end); return RValue::get(nullptr); } case Builtin::BI__builtin_trap: { - builder.create(getLoc(E->getExprLoc())); + cir::TrapOp::create(builder, getLoc(E->getExprLoc())); // Note that cir.trap is a terminator so we need to start a new block to // preserve the insertion point. @@ -1561,8 +1561,8 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, return emitUnaryFPBuiltin(*this, *E); } mlir::Value arg = emitScalarExpr(E->getArg(0)); - auto call = getBuilder().create(getLoc(E->getExprLoc()), - arg.getType(), arg, false); + auto call = cir::AbsOp::create(getBuilder(), getLoc(E->getExprLoc()), + arg.getType(), arg, false); mlir::Value result = call->getResult(0); return RValue::get(result); } @@ -1673,7 +1673,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(*this, E); mlir::Location Loc = getLoc(E->getBeginLoc()); mlir::Value Arg = emitScalarExpr(E->getArg(0)); - mlir::Value AbsArg = builder.create(Loc, Arg.getType(), Arg); + mlir::Value AbsArg = cir::FAbsOp::create(builder, Loc, Arg.getType(), Arg); mlir::Value IsInf = builder.createIsFPClass(Loc, AbsArg, FPClassTest::fcInf); mlir::Value IsNeg = emitSignBit(Loc, *this, Arg); @@ -1796,9 +1796,9 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, E->getArg(1)->getExprLoc(), FD, 1); uint64_t size = E->getArg(2)->EvaluateKnownConstInt(getContext()).getZExtValue(); - builder.create(getLoc(E->getSourceRange()), - dest.getPointer(), src.getPointer(), - builder.getI64IntegerAttr(size)); + cir::MemCpyInlineOp::create(builder, getLoc(E->getSourceRange()), + dest.getPointer(), src.getPointer(), + builder.getI64IntegerAttr(size)); // __builtin_memcpy_inline has no return value return RValue::get(nullptr); } @@ -1811,7 +1811,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, mlir::Value pattern = emitScalarExpr(E->getArg(1)); mlir::Value len = emitScalarExpr(E->getArg(2)); mlir::Value res = - builder.create(getLoc(E->getExprLoc()), src, pattern, len); + MemChrOp::create(builder, getLoc(E->getExprLoc()), src, pattern, len); return RValue::get(res); } @@ -1913,11 +1913,11 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, E->getArg(0), E->getArg(0)->getType()); uint64_t level = mlir::cast(levelAttr).getUInt(); if (BuiltinID == Builtin::BI__builtin_return_address) { - return RValue::get(builder.create( - loc, builder.getUInt32(level, loc))); + return RValue::get(cir::ReturnAddrOp::create( + builder, loc, builder.getUInt32(level, loc))); } return RValue::get( - builder.create(loc, builder.getUInt32(level, loc))); + cir::FrameAddrOp::create(builder, loc, builder.getUInt32(level, loc))); } case Builtin::BI_ReturnAddress: llvm_unreachable("BI_ReturnAddress NYI"); @@ -1968,7 +1968,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, mlir::Location loc = getLoc(E->getExprLoc()); cir::EhLongjmpOp::create(builder, loc, buf); - builder.create(loc); + cir::UnreachableOp::create(builder, loc); return RValue::get(nullptr); } case Builtin::BI__builtin_launder: { @@ -2798,8 +2798,8 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, args.push_back(argValue); } - auto intrinsicCall = builder.create( - getLoc(E->getExprLoc()), builder.getStringAttr(name), + auto intrinsicCall = cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), builder.getStringAttr(name), intrinsicType.getReturnType(), args); mlir::Type builtinReturnType = intrinsicCall.getResult().getType(); @@ -2958,9 +2958,9 @@ void CIRGenFunction::emitVAStartEnd(mlir::Value ArgValue, bool IsStart) { // LLVM codegen casts to *i8, no real gain on doing this for CIRGen this // early, defer to LLVM lowering. if (IsStart) - builder.create(ArgValue.getLoc(), ArgValue); + cir::VAStartOp::create(builder, ArgValue.getLoc(), ArgValue); else - builder.create(ArgValue.getLoc(), ArgValue); + cir::VAEndOp::create(builder, ArgValue.getLoc(), ArgValue); } /// Checks if using the result of __builtin_object_size(p, @p From) in place of diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp index ff43a24bd0df..65f8dd822399 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp @@ -2071,8 +2071,8 @@ static mlir::Value emitArmLdrexNon128Intrinsic(unsigned int builtinID, // which can be found under LLVM IR directory. mlir::Type funcResTy = builder.getSInt64Ty(); mlir::Location loc = cgf.getLoc(clangCallExpr->getExprLoc()); - cir::LLVMIntrinsicCallOp op = builder.create( - loc, builder.getStringAttr(intrinsicName), funcResTy, loadAddr); + cir::LLVMIntrinsicCallOp op = cir::LLVMIntrinsicCallOp::create( + builder, loc, builder.getStringAttr(intrinsicName), funcResTy, loadAddr); mlir::Value res = op.getResult(); // Convert result type to the expected type. @@ -2150,7 +2150,7 @@ static mlir::Value emitNeonShiftVector(CIRGenBuilderTy &builder, cir::IntAttr::get(vecTy.getElementType(), shiftAmt)}; cir::ConstVectorAttr constVecAttr = cir::ConstVectorAttr::get( vecTy, mlir::ArrayAttr::get(builder.getContext(), vecAttr)); - return builder.create(loc, constVecAttr); + return cir::ConstantOp::create(builder, loc, constVecAttr); } /// Build ShiftOp of vector type whose shift amount is a vector built @@ -2160,8 +2160,9 @@ emitCommonNeonShift(CIRGenBuilderTy &builder, mlir::Location loc, cir::VectorType resTy, mlir::Value shifTgt, mlir::Value shiftAmt, bool shiftLeft, bool negAmt = false) { shiftAmt = emitNeonShiftVector(builder, shiftAmt, resTy, loc, negAmt); - return builder.create( - loc, resTy, builder.createBitcast(shifTgt, resTy), shiftAmt, shiftLeft); + return cir::ShiftOp::create(builder, loc, resTy, + builder.createBitcast(shifTgt, resTy), shiftAmt, + shiftLeft); } /// Right-shift a vector by a constant. @@ -2202,9 +2203,10 @@ static void vecExtendIntValue(CIRGenFunction &cgf, cir::VectorType argVTy, arg = builder.createIntCast(arg, eltTy); mlir::Value zero = builder.getConstInt(loc, cgf.SizeTy, 0); mlir::Value poison = - builder.create(loc, cir::PoisonAttr::get(eltTy)); - arg = builder.create( - loc, builder.create(loc, argVTy, poison), arg, zero); + cir::ConstantOp::create(builder, loc, cir::PoisonAttr::get(eltTy)); + arg = cir::VecInsertOp::create( + builder, loc, cir::VecSplatOp::create(builder, loc, argVTy, poison), arg, + zero); } /// Reduce vector type value to scalar, usually for result of a @@ -2213,8 +2215,8 @@ static mlir::Value vecReduceIntValue(CIRGenFunction &cgf, mlir::Value val, mlir::Location loc) { CIRGenBuilderTy &builder = cgf.getBuilder(); assert(mlir::isa(val.getType())); - return builder.create( - loc, val, builder.getConstInt(loc, cgf.SizeTy, 0)); + return cir::VecExtractOp::create(builder, loc, val, + builder.getConstInt(loc, cgf.SizeTy, 0)); } template @@ -2247,12 +2249,12 @@ static mlir::Value emitNeonCallToOp( return nullptr; } if constexpr (std::is_same_v) { - return builder - .create(loc, builder.getStringAttr(intrinsicName.value()), - funcResTy, args) + return Operation::create(builder, loc, + builder.getStringAttr(intrinsicName.value()), + funcResTy, args) .getResult(); } else { - return builder.create(loc, funcResTy, args).getResult(); + return Operation::create(builder, loc, funcResTy, args).getResult(); } } @@ -2367,9 +2369,9 @@ mlir::Value CIRGenFunction::emitCommonNeonBuiltinExpr( mlir::Location loc = getLoc(e->getExprLoc()); ops[0] = builder.createBitcast(ops[0], vTy); if (mlir::isa(vTy.getElementType())) { - return builder.create(loc, ops[0]); + return cir::FAbsOp::create(builder, loc, ops[0]); } - return builder.create(loc, ops[0]); + return cir::AbsOp::create(builder, loc, ops[0]); } case NEON::BI__builtin_neon_vmovl_v: { cir::VectorType dTy = builder.getExtendedOrTruncatedElementVectorType( @@ -2506,8 +2508,8 @@ mlir::Value CIRGenFunction::emitCommonNeonBuiltinExpr( ops[0] = builder.createAnd(ops[0], ops[1]); // Note that during vmVM Lowering, result of `VecCmpOp` is sign extended, // matching traditional codegen behavior. - return builder.create(loc, ty, cir::CmpOpKind::ne, ops[0], - builder.getZero(loc, ty)); + return cir::VecCmpOp::create(builder, loc, ty, cir::CmpOpKind::ne, ops[0], + builder.getZero(loc, ty)); } } @@ -2597,9 +2599,10 @@ mlir::Value CIRGenFunction::emitCommonNeonBuiltinExpr( } case NEON::BI__builtin_neon_vshl_v: case NEON::BI__builtin_neon_vshlq_v: { - return builder.create( - getLoc(e->getExprLoc()), vTy, builder.createBitcast(ops[0], vTy), - builder.createBitcast(ops[1], vTy), true /* left */); + return cir::ShiftOp::create(builder, getLoc(e->getExprLoc()), vTy, + builder.createBitcast(ops[0], vTy), + builder.createBitcast(ops[1], vTy), + true /* left */); break; } case NEON::BI__builtin_neon_vhadd_v: @@ -3541,7 +3544,7 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, break; case NEON::BI__builtin_neon_vabsh_f16: { Ops.push_back(emitScalarExpr(E->getArg(0))); - return builder.create(getLoc(E->getExprLoc()), Ops); + return cir::FAbsOp::create(builder, getLoc(E->getExprLoc()), Ops); } case NEON::BI__builtin_neon_vaddq_p128: { llvm_unreachable("NEON::BI__builtin_neon_vaddq_p128 NYI"); @@ -3686,8 +3689,8 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, case NEON::BI__builtin_neon_vsetq_lane_i64: case NEON::BI__builtin_neon_vsetq_lane_f32: Ops.push_back(emitScalarExpr(E->getArg(2))); - return builder.create(getLoc(E->getExprLoc()), Ops[1], - Ops[0], Ops[2]); + return cir::VecInsertOp::create(builder, getLoc(E->getExprLoc()), Ops[1], + Ops[0], Ops[2]); case NEON::BI__builtin_neon_vset_lane_bf16: case NEON::BI__builtin_neon_vsetq_lane_bf16: // No support for now as no real/test case for them @@ -3698,75 +3701,75 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, case NEON::BI__builtin_neon_vset_lane_f64: { Ops.push_back(emitScalarExpr(E->getArg(2))); Ops[1] = builder.createBitcast(Ops[1], cir::VectorType::get(DoubleTy, 1)); - return builder.create(getLoc(E->getExprLoc()), Ops[1], - Ops[0], Ops[2]); + return cir::VecInsertOp::create(builder, getLoc(E->getExprLoc()), Ops[1], + Ops[0], Ops[2]); } case NEON::BI__builtin_neon_vsetq_lane_f64: { Ops.push_back(emitScalarExpr(E->getArg(2))); Ops[1] = builder.createBitcast(Ops[1], cir::VectorType::get(DoubleTy, 2)); - return builder.create(getLoc(E->getExprLoc()), Ops[1], - Ops[0], Ops[2]); + return cir::VecInsertOp::create(builder, getLoc(E->getExprLoc()), Ops[1], + Ops[0], Ops[2]); } case NEON::BI__builtin_neon_vget_lane_i8: case NEON::BI__builtin_neon_vdupb_lane_i8: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt8Ty, 8)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vgetq_lane_i8: case NEON::BI__builtin_neon_vdupb_laneq_i8: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt8Ty, 16)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vget_lane_i16: case NEON::BI__builtin_neon_vduph_lane_i16: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt16Ty, 4)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vgetq_lane_i16: case NEON::BI__builtin_neon_vduph_laneq_i16: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt16Ty, 8)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vget_lane_i32: case NEON::BI__builtin_neon_vdups_lane_i32: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt32Ty, 2)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vget_lane_f32: case NEON::BI__builtin_neon_vdups_lane_f32: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(FloatTy, 2)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vgetq_lane_i32: case NEON::BI__builtin_neon_vdups_laneq_i32: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt32Ty, 4)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vget_lane_i64: case NEON::BI__builtin_neon_vdupd_lane_i64: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt64Ty, 1)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vdupd_lane_f64: case NEON::BI__builtin_neon_vget_lane_f64: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(DoubleTy, 1)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vgetq_lane_i64: case NEON::BI__builtin_neon_vdupd_laneq_i64: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(UInt64Ty, 2)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vgetq_lane_f32: case NEON::BI__builtin_neon_vdups_laneq_f32: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(FloatTy, 4)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vgetq_lane_f64: case NEON::BI__builtin_neon_vdupd_laneq_f64: Ops[0] = builder.createBitcast(Ops[0], cir::VectorType::get(DoubleTy, 2)); - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); case NEON::BI__builtin_neon_vaddh_f16: { Ops.push_back(emitScalarExpr(E->getArg(1))); return builder.createFAdd(Ops[0], Ops[1]); @@ -3921,14 +3924,14 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, case NEON::BI__builtin_neon_vget_lane_bf16: case NEON::BI__builtin_neon_vduph_lane_bf16: case NEON::BI__builtin_neon_vduph_lane_f16: { - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); } case NEON::BI__builtin_neon_vgetq_lane_bf16: case NEON::BI__builtin_neon_vduph_laneq_bf16: case NEON::BI__builtin_neon_vduph_laneq_f16: { - return builder.create(getLoc(E->getExprLoc()), Ops[0], - emitScalarExpr(E->getArg(1))); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + emitScalarExpr(E->getArg(1))); } case NEON::BI__builtin_neon_vcvt_bf16_f32: case NEON::BI__builtin_neon_vcvtq_low_bf16_f32: @@ -4013,9 +4016,10 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, Ops[0] = builder.createBitcast(Ops[0], ty); Ops[1] = builder.createBitcast(Ops[1], ty); if (cir::isFPOrVectorOfFPType(ty)) { - return builder.create(loc, Ops[0], Ops[1]); + return cir::FMaximumOp::create(builder, loc, Ops[0], Ops[1]); } - return builder.create(loc, cir::BinOpKind::Max, Ops[0], Ops[1]); + return cir::BinOp::create(builder, loc, cir::BinOpKind::Max, Ops[0], + Ops[1]); } case NEON::BI__builtin_neon_vmaxh_f16: { llvm_unreachable("NEON::BI__builtin_neon_vmaxh_f16 NYI"); @@ -4478,30 +4482,31 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, Ops[1] = builder.createBitcast(Ops[1], vTy); Ops[0] = builder.createAlignedLoad(Ops[0].getLoc(), vTy.getElementType(), Ops[0], PtrOp0.getAlignment()); - return builder.create(getLoc(E->getExprLoc()), Ops[1], - Ops[0], Ops[2]); + return cir::VecInsertOp::create(builder, getLoc(E->getExprLoc()), Ops[1], + Ops[0], Ops[2]); } case NEON::BI__builtin_neon_vldap1_lane_s64: case NEON::BI__builtin_neon_vldap1q_lane_s64: { cir::LoadOp Load = builder.createAlignedLoad( Ops[0].getLoc(), vTy.getElementType(), Ops[0], PtrOp0.getAlignment()); Load.setAtomic(cir::MemOrder::Acquire); - return builder.create(getLoc(E->getExprLoc()), - builder.createBitcast(Ops[1], vTy), - Load, Ops[2]); + return cir::VecInsertOp::create(builder, getLoc(E->getExprLoc()), + builder.createBitcast(Ops[1], vTy), Load, + Ops[2]); } case NEON::BI__builtin_neon_vld1_dup_v: case NEON::BI__builtin_neon_vld1q_dup_v: { Address ptrAddr = PtrOp0.withElementType(builder, vTy.getElementType()); mlir::Value val = builder.createLoad(getLoc(E->getExprLoc()), ptrAddr); cir::VecSplatOp vecSplat = - builder.create(getLoc(E->getExprLoc()), vTy, val); + cir::VecSplatOp::create(builder, getLoc(E->getExprLoc()), vTy, val); return vecSplat; } case NEON::BI__builtin_neon_vst1_lane_v: case NEON::BI__builtin_neon_vst1q_lane_v: { Ops[1] = builder.createBitcast(Ops[1], ty); - Ops[1] = builder.create(Ops[1].getLoc(), Ops[1], Ops[2]); + Ops[1] = + cir::VecExtractOp::create(builder, Ops[1].getLoc(), Ops[1], Ops[2]); (void)builder.createAlignedStore(getLoc(E->getExprLoc()), Ops[1], Ops[0], PtrOp0.getAlignment()); return Ops[1]; @@ -4509,7 +4514,8 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, case NEON::BI__builtin_neon_vstl1_lane_s64: case NEON::BI__builtin_neon_vstl1q_lane_s64: { Ops[1] = builder.createBitcast(Ops[1], ty); - Ops[1] = builder.create(Ops[1].getLoc(), Ops[1], Ops[2]); + Ops[1] = + cir::VecExtractOp::create(builder, Ops[1].getLoc(), Ops[1], Ops[2]); cir::StoreOp Store = builder.createAlignedStore( getLoc(E->getExprLoc()), Ops[1], Ops[0], PtrOp0.getAlignment()); Store.setAtomic(cir::MemOrder::Release); @@ -4606,8 +4612,8 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, indices.push_back(i + e + vi); } cir::ConstantOp idx = builder.getConstInt(loc, SInt32Ty, vi); - mlir::Value addr = builder.create( - loc, baseAddr.getType(), baseAddr, idx); + mlir::Value addr = cir::PtrStrideOp::create( + builder, loc, baseAddr.getType(), baseAddr, idx); sv = builder.createVecShuffle(loc, Ops[1], Ops[2], indices); (void)builder.CIRBaseBuilderTy::createStore(loc, sv, addr); } @@ -4629,8 +4635,8 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, indices.push_back(2 * i + vi); } cir::ConstantOp idx = builder.getConstInt(loc, SInt32Ty, vi); - mlir::Value addr = builder.create( - loc, baseAddr.getType(), baseAddr, idx); + mlir::Value addr = cir::PtrStrideOp::create( + builder, loc, baseAddr.getType(), baseAddr, idx); sv = builder.createVecShuffle(loc, Ops[1], Ops[2], indices); (void)builder.CIRBaseBuilderTy::createStore(loc, sv, addr); } @@ -4653,8 +4659,8 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E, indices.push_back(((i + vi * e) >> 1) + e); } cir::ConstantOp idx = builder.getConstInt(loc, SInt32Ty, vi); - mlir::Value addr = builder.create( - loc, baseAddr.getType(), baseAddr, idx); + mlir::Value addr = cir::PtrStrideOp::create( + builder, loc, baseAddr.getType(), baseAddr, idx); sv = builder.createVecShuffle(loc, Ops[1], Ops[2], indices); (void)builder.CIRBaseBuilderTy::createStore(loc, sv, addr); } diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinNVPTX.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinNVPTX.cpp index c04cb76103c8..20a5b516ae65 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltinNVPTX.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltinNVPTX.cpp @@ -35,9 +35,8 @@ mlir::Value CIRGenFunction::emitNVPTXBuiltinExpr(unsigned builtinId, const CallExpr *expr) { [[maybe_unused]] auto getIntrinsic = [&](const char *name) { mlir::Type intTy = cir::IntType::get(&getMLIRContext(), 32, false); - return builder - .create(getLoc(expr->getExprLoc()), - builder.getStringAttr(name), intTy) + return cir::LLVMIntrinsicCallOp::create(builder, getLoc(expr->getExprLoc()), + builder.getStringAttr(name), intTy) .getResult(); }; switch (builtinId) { @@ -552,66 +551,58 @@ mlir::Value CIRGenFunction::emitNVPTXBuiltinExpr(unsigned builtinId, case NVPTX::BI__nvvm_getctarank_shared_cluster: llvm_unreachable("getctarank_shared_cluster NYI"); case NVPTX::BI__nvvm_barrier_cluster_arrive: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cluster.arrive"), - builder.getVoidTy()) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cluster.arrive"), + builder.getVoidTy()) .getResult(); case NVPTX::BI__nvvm_barrier_cluster_arrive_relaxed: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cluster.arrive.relaxed"), - builder.getVoidTy()) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cluster.arrive.relaxed"), + builder.getVoidTy()) .getResult(); case NVPTX::BI__nvvm_barrier_cluster_wait: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cluster.wait"), - builder.getVoidTy()) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cluster.wait"), + builder.getVoidTy()) .getResult(); case NVPTX::BI__nvvm_fence_sc_cluster: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.fence.sc.cluster"), builder.getVoidTy(), - mlir::ValueRange{}) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.fence.sc.cluster"), + builder.getVoidTy(), mlir::ValueRange{}) .getResult(); case NVPTX::BI__nvvm_bar_sync: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cta.sync.aligned.all"), - builder.getVoidTy(), - mlir::ValueRange{emitScalarExpr(expr->getArg(0))}) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cta.sync.aligned.all"), + builder.getVoidTy(), + mlir::ValueRange{emitScalarExpr(expr->getArg(0))}) .getResult(); case NVPTX::BI__syncthreads: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cta.sync.aligned.all"), - builder.getVoidTy(), - mlir::ValueRange{ - builder.getConstInt(getLoc(expr->getExprLoc()), SInt32Ty, 0)}) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cta.sync.aligned.all"), + builder.getVoidTy(), + mlir::ValueRange{builder.getConstInt(getLoc(expr->getExprLoc()), + SInt32Ty, 0)}) .getResult(); case NVPTX::BI__nvvm_barrier_sync: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cta.sync.all"), - builder.getVoidTy(), - mlir::ValueRange{emitScalarExpr(expr->getArg(0))}) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cta.sync.all"), + builder.getVoidTy(), + mlir::ValueRange{emitScalarExpr(expr->getArg(0))}) .getResult(); case NVPTX::BI__nvvm_barrier_sync_cnt: - return builder - .create( - getLoc(expr->getExprLoc()), - builder.getStringAttr("nvvm.barrier.cta.sync.count"), - builder.getVoidTy(), - mlir::ValueRange{emitScalarExpr(expr->getArg(0)), - emitScalarExpr(expr->getArg(1))}) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(expr->getExprLoc()), + builder.getStringAttr("nvvm.barrier.cta.sync.count"), + builder.getVoidTy(), + mlir::ValueRange{emitScalarExpr(expr->getArg(0)), + emitScalarExpr(expr->getArg(1))}) .getResult(); default: return nullptr; diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp index 544921e9fefe..1f1f6a7e5d05 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp @@ -128,10 +128,10 @@ static mlir::Value emitX86ExpandLoad(CIRGenFunction &cgf, mlir::Value maskVec = getMaskVecValue( cgf, ops[2], cast(resultTy).getSize(), loc); - return cgf.getBuilder() - .create( - loc, cgf.getBuilder().getStringAttr("masked.expandload"), resultTy, - mlir::ValueRange{ptr, maskVec, ops[1]}) + return cir::LLVMIntrinsicCallOp::create( + cgf.getBuilder(), loc, + cgf.getBuilder().getStringAttr("masked.expandload"), resultTy, + mlir::ValueRange{ptr, maskVec, ops[1]}) .getResult(); } @@ -143,10 +143,11 @@ static mlir::Value emitX86CompressStore(CIRGenFunction &cgf, mlir::Value maskVec = getMaskVecValue(cgf, ops[2], resultTy.getSize(), loc); - return cgf.getBuilder() - .create( - loc, cgf.getBuilder().getStringAttr("masked.compressstore"), - cgf.getBuilder().getVoidTy(), mlir::ValueRange{ops[1], ptr, maskVec}) + return cir::LLVMIntrinsicCallOp::create( + cgf.getBuilder(), loc, + cgf.getBuilder().getStringAttr("masked.compressstore"), + cgf.getBuilder().getVoidTy(), + mlir::ValueRange{ops[1], ptr, maskVec}) .getResult(); } @@ -263,8 +264,8 @@ static mlir::Value emitX86MaskedCompare(CIRGenFunction &cgf, unsigned cc, auto resultTy = cgf.getBuilder().getType( cgf.getBuilder().getUIntNTy(1), numElts); - cmp = cgf.getBuilder().create(loc, resultTy, pred, ops[0], - ops[1]); + cmp = cir::VecCmpOp::create(cgf.getBuilder(), loc, resultTy, pred, ops[0], + ops[1]); } mlir::Value maskIn; @@ -351,66 +352,62 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, mlir::Value Address = builder.createPtrBitcast(Ops[0], VoidTy); int64_t Hint = getIntValueFromConstOp(Ops[1]); - mlir::Value RW = builder.create( - getLoc(E->getExprLoc()), - cir::IntAttr::get(SInt32Ty, (Hint >> 2) & 0x1)); - mlir::Value Locality = builder.create( - getLoc(E->getExprLoc()), cir::IntAttr::get(SInt32Ty, Hint & 0x3)); - mlir::Value Data = builder.create( - getLoc(E->getExprLoc()), cir::IntAttr::get(SInt32Ty, 1)); + mlir::Value RW = + cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), + cir::IntAttr::get(SInt32Ty, (Hint >> 2) & 0x1)); + mlir::Value Locality = + cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), + cir::IntAttr::get(SInt32Ty, Hint & 0x3)); + mlir::Value Data = cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), + cir::IntAttr::get(SInt32Ty, 1)); mlir::Type voidTy = cir::VoidType::get(&getMLIRContext()); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("prefetch"), voidTy, - mlir::ValueRange{Address, RW, Locality, Data}) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("prefetch"), voidTy, + mlir::ValueRange{Address, RW, Locality, Data}) .getResult(); } case X86::BI_mm_clflush: { mlir::Type voidTy = cir::VoidType::get(&getMLIRContext()); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse2.clflush"), - voidTy, Ops[0]) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse2.clflush"), voidTy, Ops[0]) .getResult(); } case X86::BI_mm_lfence: { mlir::Type voidTy = cir::VoidType::get(&getMLIRContext()); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse2.lfence"), - voidTy) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse2.lfence"), voidTy) .getResult(); } case X86::BI_mm_pause: { mlir::Type voidTy = cir::VoidType::get(&getMLIRContext()); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse2.pause"), - voidTy) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse2.pause"), voidTy) .getResult(); } case X86::BI_mm_mfence: { mlir::Type voidTy = cir::VoidType::get(&getMLIRContext()); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse2.mfence"), - voidTy) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse2.mfence"), voidTy) .getResult(); } case X86::BI_mm_sfence: { mlir::Type voidTy = cir::VoidType::get(&getMLIRContext()); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse.sfence"), - voidTy) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse.sfence"), voidTy) .getResult(); } case X86::BI__rdtsc: { mlir::Type intTy = cir::IntType::get(&getMLIRContext(), 64, false); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.rdtsc"), intTy) + return cir::LLVMIntrinsicCallOp::create(builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.rdtsc"), + intTy) .getResult(); } case X86::BI__builtin_ia32_rdtscp: { @@ -418,41 +415,40 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, cir::RecordType resTy = builder.getAnonRecordTy( {builder.getUInt64Ty(), builder.getUInt32Ty()}, false, false); - auto call = builder - .create( - getLoc(E->getExprLoc()), - builder.getStringAttr("x86.rdtscp"), resTy) + auto call = cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.rdtscp"), resTy) .getResult(); // Store processor ID in address param - mlir::Value pID = builder.create( - getLoc(E->getExprLoc()), builder.getUInt32Ty(), call, 1); - builder.create(getLoc(E->getExprLoc()), pID, Ops[0]); + mlir::Value pID = cir::ExtractMemberOp::create( + builder, getLoc(E->getExprLoc()), builder.getUInt32Ty(), call, 1); + cir::StoreOp::create(builder, getLoc(E->getExprLoc()), pID, Ops[0]); // Return the timestamp at index 0 - return builder.create(getLoc(E->getExprLoc()), - builder.getUInt64Ty(), call, 0); + return cir::ExtractMemberOp::create(builder, getLoc(E->getExprLoc()), + builder.getUInt64Ty(), call, 0); } case X86::BI__builtin_ia32_lzcnt_u16: case X86::BI__builtin_ia32_lzcnt_u32: case X86::BI__builtin_ia32_lzcnt_u64: { - mlir::Value V = builder.create( - getLoc(E->getExprLoc()), cir::BoolAttr::get(&getMLIRContext(), false)); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("ctlz"), - Ops[0].getType(), mlir::ValueRange{Ops[0], V}) + mlir::Value V = + cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), + cir::BoolAttr::get(&getMLIRContext(), false)); + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), builder.getStringAttr("ctlz"), + Ops[0].getType(), mlir::ValueRange{Ops[0], V}) .getResult(); } case X86::BI__builtin_ia32_tzcnt_u16: case X86::BI__builtin_ia32_tzcnt_u32: case X86::BI__builtin_ia32_tzcnt_u64: { - mlir::Value V = builder.create( - getLoc(E->getExprLoc()), cir::BoolAttr::get(&getMLIRContext(), false)); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("cttz"), - Ops[0].getType(), mlir::ValueRange{Ops[0], V}) + mlir::Value V = + cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), + cir::BoolAttr::get(&getMLIRContext(), false)); + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), builder.getStringAttr("cttz"), + Ops[0].getType(), mlir::ValueRange{Ops[0], V}) .getResult(); } case X86::BI__builtin_ia32_undef128: @@ -485,12 +481,12 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, auto indexAttr = cir::IntAttr::get( cir::IntType::get(&getMLIRContext(), 64, false), index); auto indexVal = - builder.create(getLoc(E->getExprLoc()), indexAttr); + cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), indexAttr); // These builtins exist so we can ensure the index is an ICE and in range. // Otherwise we could just do this in the header file. - return builder.create(getLoc(E->getExprLoc()), Ops[0], - indexVal); + return cir::VecExtractOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + indexVal); } case X86::BI__builtin_ia32_vec_set_v4hi: case X86::BI__builtin_ia32_vec_set_v16qi: @@ -511,31 +507,30 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, auto indexAttr = cir::IntAttr::get( cir::IntType::get(&getMLIRContext(), 64, false), index); auto indexVal = - builder.create(getLoc(E->getExprLoc()), indexAttr); + cir::ConstantOp::create(builder, getLoc(E->getExprLoc()), indexAttr); // These builtins exist so we can ensure the index is an ICE and in range. // Otherwise we could just do this in the header file. - return builder.create(getLoc(E->getExprLoc()), Ops[0], - Ops[1], indexVal); + return cir::VecInsertOp::create(builder, getLoc(E->getExprLoc()), Ops[0], + Ops[1], indexVal); } case X86::BI_mm_setcsr: case X86::BI__builtin_ia32_ldmxcsr: { Address tmp = CreateMemTemp(E->getArg(0)->getType(), getLoc(E->getExprLoc())); builder.createStore(getLoc(E->getExprLoc()), Ops[0], tmp); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse.ldmxcsr"), - builder.getVoidTy(), tmp.getPointer()) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse.ldmxcsr"), builder.getVoidTy(), + tmp.getPointer()) .getResult(); } case X86::BI_mm_getcsr: case X86::BI__builtin_ia32_stmxcsr: { Address tmp = CreateMemTemp(E->getType(), getLoc(E->getExprLoc())); - builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr("x86.sse.stmxcsr"), - builder.getVoidTy(), tmp.getPointer()) + cir::LLVMIntrinsicCallOp::create(builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.sse.stmxcsr"), + builder.getVoidTy(), tmp.getPointer()) .getResult(); return builder.createLoad(getLoc(E->getExprLoc()), tmp); } @@ -612,17 +607,16 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, Ops[1] = mhi; Ops.push_back(mlo); - return builder - .create( - loc, builder.getStringAttr(intrinsicName), builder.getVoidTy(), Ops) + return cir::LLVMIntrinsicCallOp::create( + builder, loc, builder.getStringAttr(intrinsicName), + builder.getVoidTy(), Ops) .getResult(); } case X86::BI__builtin_ia32_xgetbv: case X86::BI_xgetbv: - return builder - .create(getLoc(E->getExprLoc()), - builder.getStringAttr("x86.xgetbv"), - builder.getUInt64Ty(), Ops) + return cir::LLVMIntrinsicCallOp::create(builder, getLoc(E->getExprLoc()), + builder.getStringAttr("x86.xgetbv"), + builder.getUInt64Ty(), Ops) .getResult(); case X86::BI__builtin_ia32_storedqudi128_mask: case X86::BI__builtin_ia32_storedqusi128_mask: @@ -996,10 +990,10 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, std::min(cast(Ops[0].getType()).getSize(), cast(Ops[2].getType()).getSize()); Ops[3] = getMaskVecValue(*this, Ops[3], minElts, getLoc(E->getExprLoc())); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr(intrinsicName.str()), - convertType(E->getType()), Ops) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr(intrinsicName.str()), + convertType(E->getType()), Ops) .getResult(); } case X86::BI__builtin_ia32_scattersiv8df: @@ -1109,10 +1103,10 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID, cast(Ops[3].getType()).getSize()); Ops[1] = getMaskVecValue(*this, Ops[1], minElts, getLoc(E->getExprLoc())); - return builder - .create( - getLoc(E->getExprLoc()), builder.getStringAttr(intrinsicName.str()), - builder.getVoidTy(), Ops) + return cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), + builder.getStringAttr(intrinsicName.str()), builder.getVoidTy(), + Ops) .getResult(); } diff --git a/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp b/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp index 112d268a64d5..31011131be48 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp @@ -223,15 +223,15 @@ void CIRGenNVCUDARuntime::emitDeviceStubBodyNew(CIRGenFunction &cgf, if (auto globalOp = llvm::dyn_cast_or_null( KernelHandles[fn.getSymName()])) { auto kernelTy = cir::PointerType::get(globalOp.getSymType()); - mlir::Value kernel = builder.create( - loc, kernelTy, globalOp.getSymName()); + mlir::Value kernel = cir::GetGlobalOp::create(builder, loc, kernelTy, + globalOp.getSymName()); return kernel; } if (auto funcOp = llvm::dyn_cast_or_null( KernelHandles[fn.getSymName()])) { auto kernelTy = cir::PointerType::get(funcOp.getFunctionType()); mlir::Value kernel = - builder.create(loc, kernelTy, funcOp.getSymName()); + cir::GetGlobalOp::create(builder, loc, kernelTy, funcOp.getSymName()); mlir::Value func = builder.createBitcast(kernel, cgm.VoidPtrTy); return func; } diff --git a/clang/lib/CIR/CodeGen/CIRGenCUDARuntime.cpp b/clang/lib/CIR/CodeGen/CIRGenCUDARuntime.cpp index 5ec8d86ab6c2..11b7a3b377ef 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCUDARuntime.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCUDARuntime.cpp @@ -31,13 +31,13 @@ RValue CIRGenCUDARuntime::emitCUDAKernelCallExpr(CIRGenFunction &cgf, cgf.emitIfOnBoolExpr( expr->getConfig(), [&](mlir::OpBuilder &b, mlir::Location l) { - b.create(loc); + cir::YieldOp::create(b, loc); }, loc, [&](mlir::OpBuilder &b, mlir::Location l) { CIRGenCallee callee = cgf.emitCallee(expr->getCallee()); cgf.emitCall(expr->getCallee()->getType(), callee, expr, retValue); - b.create(loc); + cir::YieldOp::create(b, loc); }, loc); diff --git a/clang/lib/CIR/CodeGen/CIRGenCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenCXX.cpp index 04d236a2a7b0..c697e2091e76 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCXX.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCXX.cpp @@ -372,7 +372,7 @@ void CIRGenModule::emitCXXGlobalVarDeclInit(const VarDecl *varDecl, getASTContext().getDeclAlign(varDecl)); emitDeclInit(cgf, varDecl, declAddr); builder.setInsertionPointToEnd(block); - builder.create(addr->getLoc()); + cir::YieldOp::create(builder, addr->getLoc()); } if (varDecl->getType().isConstantStorage(getASTContext(), true, @@ -396,7 +396,7 @@ void CIRGenModule::emitCXXGlobalVarDeclInit(const VarDecl *varDecl, // Don't confuse lexical cleanup. builder.clearInsertionPoint(); } else - builder.create(addr->getLoc()); + cir::YieldOp::create(builder, addr->getLoc()); } return; } @@ -428,5 +428,5 @@ void CIRGenModule::emitCXXGlobalVarDeclInit(const VarDecl *varDecl, cgf.emitStoreOfScalar(rv.getScalarVal(), declAddr, false, ty); } builder.setInsertionPointToEnd(block); - builder.create(addr->getLoc()); + cir::YieldOp::create(builder, addr->getLoc()); } diff --git a/clang/lib/CIR/CodeGen/CIRGenCall.cpp b/clang/lib/CIR/CodeGen/CIRGenCall.cpp index 81782ad558f5..bb864c7cd042 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCall.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCall.cpp @@ -335,8 +335,8 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc, if (op) return op; - op = builder.create( - *CGF.currSrcLoc, /*scopeBuilder=*/ + op = cir::TryOp::create( + builder, *CGF.currSrcLoc, /*scopeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) {}, // Don't emit the code right away for catch clauses, for // now create the regions and consume the try scope result. @@ -348,7 +348,7 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc, // handler: unwind. auto *r = result.addRegion(); builder.createBlock(r); - builder.create(loc, mlir::Value{}, mlir::Value{}); + cir::ResumeOp::create(builder, loc, mlir::Value{}, mlir::Value{}); }); op.setSynthetic(true); return op; @@ -391,7 +391,7 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc, CGF.callWithExceptionCtx = nullptr; if (tryOp.getSynthetic()) { - builder.create(tryOp.getLoc()); + cir::YieldOp::create(builder, tryOp.getLoc()); builder.restoreInsertionPoint(ip); } return callOpWithExceptions; @@ -1432,7 +1432,7 @@ mlir::Value CIRGenFunction::emitVAArg(VAArgExpr *VE, Address &VAListAddr) { auto loc = CGM.getLoc(VE->getExprLoc()); auto type = convertType(VE->getType()); auto vaList = emitVAListRef(VE->getSubExpr()).getPointer(); - return builder.create(loc, type, vaList); + return cir::VAArgOp::create(builder, loc, type, vaList); } static void getTrivialDefaultFunctionAttributes( diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp index 11a256e7de10..dbbc3b439619 100644 --- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp @@ -748,8 +748,8 @@ static Address ApplyNonVirtualAndVirtualOffset( mlir::Type charPtrType = CGF.CGM.UInt8PtrTy; mlir::Value charPtr = CGF.getBuilder().createCast(cir::CastKind::bitcast, ptr, charPtrType); - mlir::Value adjusted = CGF.getBuilder().create( - loc, charPtrType, charPtr, baseOffset); + mlir::Value adjusted = cir::PtrStrideOp::create( + CGF.getBuilder(), loc, charPtrType, charPtr, baseOffset); ptr = CGF.getBuilder().createCast(cir::CastKind::bitcast, adjusted, ptr.getType()); @@ -807,8 +807,8 @@ void CIRGenFunction::initializeVTablePointer(mlir::Location loc, // vtable field is derived from `this` pointer, therefore they should be in // the same addr space. assert(!cir::MissingFeatures::addressSpace()); - auto VTablePtr = builder.create( - loc, builder.getPtrToVPtrType(), ClassAddr.getPointer()); + auto VTablePtr = cir::VTableGetVPtrOp::create( + builder, loc, builder.getPtrToVPtrType(), ClassAddr.getPointer()); Address VTableField = Address(VTablePtr, ClassAddr.getAlignment()); auto storeOp = builder.createStore(loc, VTableAddressPoint, VTableField); TBAAAccessInfo TBAAInfo = @@ -1196,7 +1196,7 @@ void CIRGenFunction::emitDestructorBody(FunctionArgList &Args) { if (DtorType != Dtor_Base && Dtor->getParent()->isAbstract()) { SourceLocation Loc = Dtor->hasBody() ? Dtor->getBody()->getBeginLoc() : Dtor->getLocation(); - builder.create(getLoc(Loc)); + cir::TrapOp::create(builder, getLoc(Loc)); // The corresponding clang/CodeGen logic clears the insertion point here, // but MLIR's builder requires a valid insertion point, so we create a dummy // block (since the trap is a block terminator). @@ -1706,8 +1706,8 @@ void CIRGenFunction::emitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, mlir::Value CIRGenFunction::getVTablePtr(mlir::Location Loc, Address This, const CXXRecordDecl *RD) { - auto VTablePtr = builder.create( - Loc, builder.getPtrToVPtrType(), This.getPointer()); + auto VTablePtr = cir::VTableGetVPtrOp::create( + builder, Loc, builder.getPtrToVPtrType(), This.getPointer()); Address VTablePtrAddr = Address(VTablePtr, This.getAlignment()); auto VTable = builder.createLoad(Loc, VTablePtrAddr); @@ -1892,8 +1892,9 @@ void CIRGenFunction::emitCXXAggrConstructorCall( // Emit the constructor call that will execute for every array element. auto arrayOp = builder.createPtrBitcast(arrayBase.getPointer(), arrayTy); - builder.create( - *currSrcLoc, arrayOp, [&](mlir::OpBuilder &b, mlir::Location loc) { + cir::ArrayCtor::create( + builder, *currSrcLoc, arrayOp, + [&](mlir::OpBuilder &b, mlir::Location loc) { auto arg = b.getInsertionBlock()->addArgument(ptrToElmType, loc); Address curAddr = Address(arg, elementType, eltAlignment); auto currAVS = AggValueSlot::forAddr( @@ -1905,7 +1906,7 @@ void CIRGenFunction::emitCXXAggrConstructorCall( emitCXXConstructorCall(ctor, Ctor_Complete, /*ForVirtualBase=*/false, /*Delegating=*/false, currAVS, E); - builder.create(loc); + cir::YieldOp::create(builder, loc); }); } } diff --git a/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp b/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp index 84f479a3c832..7989536df538 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCleanup.cpp @@ -42,7 +42,7 @@ cir::BrOp CIRGenFunction::emitBranchThroughCleanup(mlir::Location Loc, // Insert a branch: to the cleanup block (unsolved) or to the already // materialized label. Keep track of unsolved goto's. assert(Dest.getBlock() && "assumes incoming valid dest"); - auto brOp = builder.create(Loc, Dest.getBlock()); + auto brOp = BrOp::create(builder, Loc, Dest.getBlock()); // Calculate the innermost active normal cleanup. EHScopeStack::stable_iterator TopCleanup = @@ -319,11 +319,11 @@ static void emitCleanup(CIRGenFunction &CGF, EHScopeStack::Cleanup *Fn, if (ActiveFlag.isValid()) { mlir::Value isActive = builder.createLoad(loc, ActiveFlag); - builder.create(loc, isActive, false, - [&](mlir::OpBuilder &b, mlir::Location) { - emitCleanup(); - builder.createYield(loc); - }); + cir::IfOp::create(builder, loc, isActive, false, + [&](mlir::OpBuilder &b, mlir::Location) { + emitCleanup(); + builder.createYield(loc); + }); } else { emitCleanup(); } diff --git a/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp b/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp index a84b63113512..ed99328a8dc5 100644 --- a/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenCoroutine.cpp @@ -266,20 +266,19 @@ CIRGenFunction::emitCoroutineBody(const CoroutineBodyStmt &S) { auto storeAddr = coroFrame.getPointer(); builder.CIRBaseBuilderTy::createStore(openCurlyLoc, nullPtrCst, storeAddr); - builder.create(openCurlyLoc, coroAlloc.getResult(), - /*withElseRegion=*/false, - /*thenBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - builder.CIRBaseBuilderTy::createStore( - loc, emitScalarExpr(S.getAllocate()), - storeAddr); - builder.create(loc); - }); + cir::IfOp::create(builder, openCurlyLoc, coroAlloc.getResult(), + /*withElseRegion=*/false, + /*thenBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + builder.CIRBaseBuilderTy::createStore( + loc, emitScalarExpr(S.getAllocate()), storeAddr); + cir::YieldOp::create(builder, loc); + }); CurCoro.Data->CoroBegin = emitCoroBeginBuiltinCall( openCurlyLoc, - builder.create(openCurlyLoc, allocaTy, storeAddr)) + cir::LoadOp::create(builder, openCurlyLoc, allocaTy, storeAddr)) .getResult(); // Handle allocation failure if 'ReturnStmtOnAllocFailure' was provided. @@ -417,8 +416,8 @@ emitSuspendExpression(CIRGenFunction &CGF, CGCoroData &Coro, auto UnbindOnExit = llvm::make_scope_exit([&] { Binder.unbind(CGF); }); auto &builder = CGF.getBuilder(); - [[maybe_unused]] auto awaitOp = builder.create( - CGF.getLoc(S.getSourceRange()), Kind, + [[maybe_unused]] auto awaitOp = cir::AwaitOp::create( + builder, CGF.getLoc(S.getSourceRange()), Kind, /*readyBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { Expr *condExpr = S.getReadyExpr()->IgnoreParens(); @@ -441,7 +440,7 @@ emitSuspendExpression(CIRGenFunction &CGF, CGCoroData &Coro, } // Signals the parent that execution flows to next region. - builder.create(loc); + cir::YieldOp::create(builder, loc); }, /*resumeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { @@ -479,7 +478,7 @@ emitSuspendExpression(CIRGenFunction &CGF, CGCoroData &Coro, } // Returns control back to parent. - builder.create(loc); + cir::YieldOp::create(builder, loc); }); assert(awaitBuild.succeeded() && "Should know how to codegen"); @@ -513,8 +512,9 @@ static RValue emitSuspendExpr(CIRGenFunction &CGF, return rval; if (rval.isScalar()) { - rval = RValue::get(CGF.getBuilder().create( - scopeLoc, rval.getScalarVal().getType(), tmpResumeRValAddr)); + rval = RValue::get(cir::LoadOp::create(CGF.getBuilder(), scopeLoc, + rval.getScalarVal().getType(), + tmpResumeRValAddr)); } else if (rval.isAggregate()) { // This is probably already handled via AggSlot, remove this assertion // once we have a testcase and prove all pieces work. @@ -558,7 +558,8 @@ mlir::LogicalResult CIRGenFunction::emitCoreturnStmt(CoreturnStmt const &S) { // scope cleanup handling. auto loc = getLoc(S.getSourceRange()); auto *retBlock = currLexScope->getOrCreateRetBlock(*this, loc); - CurCoro.Data->FinalSuspendInsPoint = builder.create(loc, retBlock); + CurCoro.Data->FinalSuspendInsPoint = + cir::BrOp::create(builder, loc, retBlock); // Insert the new block to continue codegen after branch to ret block, // this will likely be an empty block. diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp index 0d1932071c73..0902128fd62f 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp @@ -682,7 +682,8 @@ void CIRGenFunction::emitStaticVarDecl(const VarDecl &D, // and that's already updated, but for unions the type might be different, // we need to cast to the expected type. auto castedAddr = builder.createBitcast(getAddrOp.getAddr(), expectedType); - auto actualElemTy = llvm::cast(castedAddr.getType()).getPointee(); + auto actualElemTy = + llvm::cast(castedAddr.getType()).getPointee(); LocalDeclMap.find(&D)->second = Address(castedAddr, actualElemTy, alignment); CGM.setStaticLocalDeclAddress(&D, var); @@ -1109,8 +1110,8 @@ void CIRGenFunction::emitArrayDestroy(mlir::Value begin, mlir::Value end, auto ptrToElmType = builder.getPointerTo(cirElementType); // Emit the dtor call that will execute for every array element. - builder.create( - *currSrcLoc, begin, [&](mlir::OpBuilder &b, mlir::Location loc) { + cir::ArrayDtor::create( + builder, *currSrcLoc, begin, [&](mlir::OpBuilder &b, mlir::Location loc) { auto arg = b.getInsertionBlock()->addArgument(ptrToElmType, loc); Address curAddr = Address(arg, cirElementType, elementAlign); if (useEHCleanup) { @@ -1124,7 +1125,7 @@ void CIRGenFunction::emitArrayDestroy(mlir::Value begin, mlir::Value end, if (useEHCleanup) PopCleanupBlock(); - builder.create(loc); + cir::YieldOp::create(builder, loc); }); } @@ -1271,7 +1272,7 @@ void CIRGenFunction::pushDestroyAndDeferDeactivation( CleanupKind cleanupKind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray) { mlir::Operation *flag = - builder.create(builder.getUnknownLoc()); + cir::UnreachableOp::create(builder, builder.getUnknownLoc()); pushDestroy(cleanupKind, addr, type, destroyer, useEHCleanupForArray); DeferredDeactivationCleanupStack.push_back({EHStack.stable_begin(), flag}); } diff --git a/clang/lib/CIR/CodeGen/CIRGenException.cpp b/clang/lib/CIR/CodeGen/CIRGenException.cpp index c2f35f53125b..58f5b4efcfef 100644 --- a/clang/lib/CIR/CodeGen/CIRGenException.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenException.cpp @@ -221,8 +221,8 @@ struct FreeException final : EHScopeStack::Cleanup { CIRGenBuilderTy &builder = CGF.getBuilder(); mlir::Location loc = CGF.currSrcLoc ? *CGF.currSrcLoc : builder.getUnknownLoc(); - builder.create( - loc, builder.createBitcast(exn, builder.getVoidPtrTy())); + cir::FreeExceptionOp::create( + builder, loc, builder.createBitcast(exn, builder.getVoidPtrTy())); } }; } // end anonymous namespace @@ -281,7 +281,7 @@ void CIRGenFunction::emitEHResumeBlock(bool isCleanup, llvm_unreachable("NYI"); } - getBuilder().create(loc, mlir::Value{}, mlir::Value{}); + cir::ResumeOp::create(getBuilder(), loc, mlir::Value{}, mlir::Value{}); getBuilder().restoreInsertionPoint(ip); mayThrow = true; } @@ -310,18 +310,17 @@ mlir::LogicalResult CIRGenFunction::emitCXXTryStmt(const CXXTryStmt &S) { // Create a scope to hold try local storage for catch params. [[maybe_unused]] auto s = - builder.create(loc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - scopeIP = - getBuilder().saveInsertionPoint(); - }); + cir::ScopeOp::create(builder, loc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + scopeIP = getBuilder().saveInsertionPoint(); + }); auto r = mlir::success(); { mlir::OpBuilder::InsertionGuard guard(getBuilder()); getBuilder().restoreInsertionPoint(scopeIP); r = emitCXXTryStmtUnderScope(S); - getBuilder().create(loc); + cir::YieldOp::create(getBuilder(), loc); } return r; } @@ -353,8 +352,8 @@ CIRGenFunction::emitCXXTryStmtUnderScope(const CXXTryStmt &S) { // don't populate right away. Reserve some space to store the exception // info but don't emit the bulk right away, for now only make sure the // scope returns the exception information. - auto tryOp = builder.create( - tryLoc, /*scopeBuilder=*/ + auto tryOp = cir::TryOp::create( + builder, tryLoc, /*scopeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { beginInsertTryBody = getBuilder().saveInsertionPoint(); }, diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp index ce31e9da11f3..4c4f0fc2c0f4 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp @@ -700,8 +700,8 @@ RValue CIRGenFunction::emitLoadOfLValue(LValue LV, SourceLocation Loc) { if (LV.isVectorElt()) { auto load = builder.createLoad(getLoc(Loc), LV.getVectorAddress()); - return RValue::get(builder.create(getLoc(Loc), load, - LV.getVectorIdx())); + return RValue::get(cir::VecExtractOp::create(builder, getLoc(Loc), load, + LV.getVectorIdx())); } if (LV.isExtVectorElt()) { @@ -739,7 +739,7 @@ RValue CIRGenFunction::emitLoadOfExtVectorElementLValue(LValue LV) { int64_t InIdx = getAccessedFieldNo(0, Elts); cir::ConstantOp Elt = builder.getConstInt(loc, builder.getSInt64Ty(), InIdx); - return RValue::get(builder.create(loc, Vec, Elt)); + return RValue::get(cir::VecExtractOp::create(builder, loc, Vec, Elt)); } // Always use shuffle vector to try to retain the original program structure @@ -837,7 +837,7 @@ void CIRGenFunction::emitStoreThroughExtVectorComponentLValue(RValue Src, unsigned InIdx = getAccessedFieldNo(0, Elts); auto Elt = builder.getSInt64(InIdx, loc); - Vec = builder.create(loc, Vec, SrcVal, Elt); + Vec = cir::VecInsertOp::create(builder, loc, Vec, SrcVal, Elt); } builder.createStore(loc, Vec, Dst.getExtVectorAddress(), @@ -851,8 +851,8 @@ void CIRGenFunction::emitStoreThroughLValue(RValue Src, LValue Dst, // Read/modify/write the vector, inserting the new element mlir::Location loc = Dst.getVectorPointer().getLoc(); mlir::Value Vector = builder.createLoad(loc, Dst.getVectorAddress()); - Vector = builder.create(loc, Vector, Src.getScalarVal(), - Dst.getVectorIdx()); + Vector = cir::VecInsertOp::create(builder, loc, Vector, + Src.getScalarVal(), Dst.getVectorIdx()); builder.createStore(loc, Vector, Dst.getVectorAddress()); return; } @@ -992,15 +992,15 @@ static LValue emitFunctionDeclLValue(CIRGenFunction &CGF, const Expr *E, mlir::Type fnTy = funcOp.getFunctionType(); auto ptrTy = cir::PointerType::get(fnTy); - mlir::Value addr = CGF.getBuilder().create( - loc, ptrTy, funcOp.getSymName()); + mlir::Value addr = cir::GetGlobalOp::create(CGF.getBuilder(), loc, ptrTy, + funcOp.getSymName()); if (funcOp.getFunctionType() != CGF.convertType(FD->getType())) { fnTy = CGF.convertType(FD->getType()); ptrTy = cir::PointerType::get(fnTy); - addr = CGF.getBuilder().create(addr.getLoc(), ptrTy, - cir::CastKind::bitcast, addr); + addr = cir::CastOp::create(CGF.getBuilder(), addr.getLoc(), ptrTy, + cir::CastKind::bitcast, addr); } return CGF.makeAddrLValue(Address(addr, fnTy, align), E->getType(), @@ -1556,8 +1556,8 @@ RValue CIRGenFunction::emitCall(clang::QualType CalleeType, auto *Fn = Callee.getFunctionPointer(); mlir::Value Addr; if (auto funcOp = llvm::dyn_cast(Fn)) { - Addr = builder.create( - getLoc(E->getSourceRange()), + Addr = cir::GetGlobalOp::create( + builder, getLoc(E->getSourceRange()), cir::PointerType::get(funcOp.getFunctionType()), funcOp.getSymName()); } else { Addr = Fn->getResult(0); @@ -2510,63 +2510,61 @@ CIRGenFunction::emitConditionalBlocks(const AbstractConditionalOperator *E, // Block does not return: build empty yield. if (mlir::isa(yieldTy)) { - builder.create(loc); + cir::YieldOp::create(builder, loc); } else { // Block returns: set null yield value. mlir::Value op0 = builder.getNullValue(yieldTy, loc); - builder.create(loc, op0); + cir::YieldOp::create(builder, loc, op0); } } }; - Info.Result = - builder - .create( - loc, condV, /*trueBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - CIRGenFunction::LexicalScope lexScope{*this, loc, - b.getInsertionBlock()}; - CGF.currLexScope->setAsTernary(); - - assert(!cir::MissingFeatures::incrementProfileCounter()); - eval.begin(CGF); - Info.LHS = BranchGenFunc(CGF, trueExpr); - auto lhs = Info.LHS->getPointer(); - eval.end(CGF); - - if (lhs) { - yieldTy = lhs.getType(); - b.create(loc, lhs); - return; - } - // If LHS or RHS is a throw or void expression we need - // to patch arms as to properly match yield types. - insertPoints.push_back(b.saveInsertionPoint()); - }, - /*falseBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - CIRGenFunction::LexicalScope lexScope{*this, loc, - b.getInsertionBlock()}; - CGF.currLexScope->setAsTernary(); - - assert(!cir::MissingFeatures::incrementProfileCounter()); - eval.begin(CGF); - Info.RHS = BranchGenFunc(CGF, falseExpr); - auto rhs = Info.RHS->getPointer(); - eval.end(CGF); - - if (rhs) { - yieldTy = rhs.getType(); - b.create(loc, rhs); - } else { - // If LHS or RHS is a throw or void expression we - // need to patch arms as to properly match yield - // types. - insertPoints.push_back(b.saveInsertionPoint()); - } - - patchVoidOrThrowSites(); - }) - .getResult(); + Info.Result = cir::TernaryOp::create( + builder, loc, condV, /*trueBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + CIRGenFunction::LexicalScope lexScope{ + *this, loc, b.getInsertionBlock()}; + CGF.currLexScope->setAsTernary(); + + assert(!cir::MissingFeatures::incrementProfileCounter()); + eval.begin(CGF); + Info.LHS = BranchGenFunc(CGF, trueExpr); + auto lhs = Info.LHS->getPointer(); + eval.end(CGF); + + if (lhs) { + yieldTy = lhs.getType(); + cir::YieldOp::create(b, loc, lhs); + return; + } + // If LHS or RHS is a throw or void expression we need + // to patch arms as to properly match yield types. + insertPoints.push_back(b.saveInsertionPoint()); + }, + /*falseBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + CIRGenFunction::LexicalScope lexScope{ + *this, loc, b.getInsertionBlock()}; + CGF.currLexScope->setAsTernary(); + + assert(!cir::MissingFeatures::incrementProfileCounter()); + eval.begin(CGF); + Info.RHS = BranchGenFunc(CGF, falseExpr); + auto rhs = Info.RHS->getPointer(); + eval.end(CGF); + + if (rhs) { + yieldTy = rhs.getType(); + cir::YieldOp::create(b, loc, rhs); + } else { + // If LHS or RHS is a throw or void expression we + // need to patch arms as to properly match yield + // types. + insertPoints.push_back(b.saveInsertionPoint()); + } + + patchVoidOrThrowSites(); + }) + .getResult(); return Info; } @@ -2647,8 +2645,8 @@ LValue CIRGenFunction::emitLValue(const Expr *E) { LValue LV; auto scopeLoc = getLoc(E->getSourceRange()); - [[maybe_unused]] auto scope = builder.create( - scopeLoc, /*scopeBuilder=*/ + [[maybe_unused]] auto scope = cir::ScopeOp::create( + builder, scopeLoc, /*scopeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { CIRGenFunction::LexicalScope lexScope{*this, loc, builder.getInsertionBlock()}; @@ -2799,9 +2797,9 @@ cir::IfOp CIRGenFunction::emitIfOnBoolExpr( // Emit the code with the fully general case. mlir::Value condV = emitOpOnBoolExpr(loc, cond); - return builder.create(loc, condV, elseLoc.has_value(), - /*thenBuilder=*/thenBuilder, - /*elseBuilder=*/elseBuilder); + return cir::IfOp::create(builder, loc, condV, elseLoc.has_value(), + /*thenBuilder=*/thenBuilder, + /*elseBuilder=*/elseBuilder); } /// TODO(cir): PGO data @@ -2830,18 +2828,17 @@ mlir::Value CIRGenFunction::emitOpOnBoolExpr(mlir::Location loc, mlir::Value condV = emitOpOnBoolExpr(loc, CondOp->getCond()); auto ternaryOpRes = - builder - .create( - loc, condV, /*thenBuilder=*/ - [this, trueExpr](mlir::OpBuilder &b, mlir::Location loc) { - auto lhs = emitScalarExpr(trueExpr); - b.create(loc, lhs); - }, - /*elseBuilder=*/ - [this, falseExpr](mlir::OpBuilder &b, mlir::Location loc) { - auto rhs = emitScalarExpr(falseExpr); - b.create(loc, rhs); - }) + cir::TernaryOp::create( + builder, loc, condV, /*thenBuilder=*/ + [this, trueExpr](mlir::OpBuilder &b, mlir::Location loc) { + auto lhs = emitScalarExpr(trueExpr); + cir::YieldOp::create(b, loc, lhs); + }, + /*elseBuilder=*/ + [this, falseExpr](mlir::OpBuilder &b, mlir::Location loc) { + auto rhs = emitScalarExpr(falseExpr); + cir::YieldOp::create(b, loc, rhs); + }) .getResult(); return emitScalarConversion(ternaryOpRes, CondOp->getType(), @@ -3039,8 +3036,8 @@ Address CIRGenFunction::emitLoadOfReference(LValue refLVal, mlir::Location loc, TBAAAccessInfo *pointeeTBAAInfo) { assert(!refLVal.isVolatile() && "NYI"); cir::LoadOp load = - builder.create(loc, refLVal.getAddress().getElementType(), - refLVal.getAddress().getPointer()); + cir::LoadOp::create(builder, loc, refLVal.getAddress().getElementType(), + refLVal.getAddress().getPointer()); CGM.decorateOperationWithTBAA(load, refLVal.getTBAAInfo()); @@ -3064,7 +3061,7 @@ LValue CIRGenFunction::emitLoadOfReferenceLValue(LValue RefLVal, void CIRGenFunction::emitUnreachable(SourceLocation Loc) { if (SanOpts.has(SanitizerKind::Unreachable)) llvm_unreachable("NYI"); - builder.create(getLoc(Loc)); + cir::UnreachableOp::create(builder, getLoc(Loc)); } //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp b/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp index 85a7c36cb6a7..9139e36577eb 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp @@ -450,9 +450,9 @@ void AggExprEmitter::emitArrayInit(Address DestPtr, cir::ArrayType AType, auto loc = CGF.getLoc(ExprToVisit->getSourceRange()); // Cast from cir.ptr to cir.ptr - auto begin = CGF.getBuilder().create( - loc, cirElementPtrType, cir::CastKind::array_to_ptrdecay, - DestPtr.getPointer()); + auto begin = cir::CastOp::create(CGF.getBuilder(), loc, cirElementPtrType, + cir::CastKind::array_to_ptrdecay, + DestPtr.getPointer()); CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType); CharUnits elementAlign = @@ -488,8 +488,8 @@ void AggExprEmitter::emitArrayInit(Address DestPtr, cir::ArrayType AType, // Advance to the next element. if (i > 0) { - element = CGF.getBuilder().create( - loc, cirElementPtrType, begin, one); + element = cir::PtrStrideOp::create(CGF.getBuilder(), loc, + cirElementPtrType, begin, one); // Tell the cleanup that it needs to destroy up to this // element. TODO: some of these stores can be trivially @@ -521,8 +521,8 @@ void AggExprEmitter::emitArrayInit(Address DestPtr, cir::ArrayType AType, if (NumInitElements) { auto one = builder.getConstInt(loc, mlir::cast(CGF.PtrDiffTy), 1); - element = builder.create(loc, cirElementPtrType, - element, one); + element = cir::PtrStrideOp::create(builder, loc, cirElementPtrType, + element, one); assert(!endOfInit.isValid() && "destructed types NIY"); } @@ -537,8 +537,8 @@ void AggExprEmitter::emitArrayInit(Address DestPtr, cir::ArrayType AType, // Compute the end of array auto numArrayElementsConst = builder.getConstInt( loc, mlir::cast(CGF.PtrDiffTy), NumArrayElements); - mlir::Value end = builder.create( - loc, cirElementPtrType, begin, numArrayElementsConst); + mlir::Value end = cir::PtrStrideOp::create(builder, loc, cirElementPtrType, + begin, numArrayElementsConst); builder.createDoWhile( loc, @@ -546,8 +546,8 @@ void AggExprEmitter::emitArrayInit(Address DestPtr, cir::ArrayType AType, [&](mlir::OpBuilder &b, mlir::Location loc) { auto currentElement = builder.createLoad(loc, tmpAddr); mlir::Type boolTy = CGF.convertType(CGF.getContext().BoolTy); - auto cmp = builder.create(loc, boolTy, cir::CmpOpKind::ne, - currentElement, end); + auto cmp = cir::CmpOp::create( + builder, loc, boolTy, cir::CmpOpKind::ne, currentElement, end); builder.createCondition(cmp); }, /*bodyBuilder=*/ @@ -572,8 +572,8 @@ void AggExprEmitter::emitArrayInit(Address DestPtr, cir::ArrayType AType, // Advance pointer and store them to temporary variable auto one = builder.getConstInt( loc, mlir::cast(CGF.PtrDiffTy), 1); - auto nextElement = builder.create( - loc, cirElementPtrType, currentElement, one); + auto nextElement = cir::PtrStrideOp::create( + builder, loc, cirElementPtrType, currentElement, one); CGF.emitStoreThroughLValue(RValue::get(nextElement), tmpLV); builder.createYield(loc); @@ -856,10 +856,10 @@ void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) { auto &builder = CGF.getBuilder(); auto scopeLoc = CGF.getLoc(E->getSourceRange()); mlir::OpBuilder::InsertPoint scopeBegin; - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - scopeBegin = b.saveInsertionPoint(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + scopeBegin = b.saveInsertionPoint(); + }); { mlir::OpBuilder::InsertionGuard guard(builder); diff --git a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp index 1f4449cb5a39..7fd82d66d651 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp @@ -1319,8 +1319,8 @@ void CIRGenFunction::emitCXXDeleteExpr(const CXXDeleteExpr *E) { assert(convertTypeForMem(DeleteTy) == Ptr.getElementType()); if (E->isArrayForm()) { - builder.create(Ptr.getPointer().getLoc(), - Ptr.getPointer()); + cir::DeleteArrayOp::create(builder, Ptr.getPointer().getLoc(), + Ptr.getPointer()); } else { (void)EmitObjectDelete(*this, E, Ptr, DeleteTy); } @@ -1449,11 +1449,11 @@ mlir::Value CIRGenFunction::emitCXXNewExpr(const CXXNewExpr *E) { nullCmpResult = builder.createCompare(loc, cir::CmpOpKind::ne, allocation.getPointer(), nullPtr); preIfBody = builder.saveInsertionPoint(); - builder.create(loc, nullCmpResult, - /*withElseRegion=*/false, - [&](mlir::OpBuilder &, mlir::Location) { - ifBody = builder.saveInsertionPoint(); - }); + cir::IfOp::create(builder, loc, nullCmpResult, + /*withElseRegion=*/false, + [&](mlir::OpBuilder &, mlir::Location) { + ifBody = builder.saveInsertionPoint(); + }); postIfBody = builder.saveInsertionPoint(); } @@ -1483,7 +1483,7 @@ mlir::Value CIRGenFunction::emitCXXNewExpr(const CXXNewExpr *E) { allocatorArgs); operatorDeleteCleanup = EHStack.stable_begin(); cleanupDominator = - builder.create(getLoc(E->getSourceRange())) + cir::UnreachableOp::create(builder, getLoc(E->getSourceRange())) .getOperation(); } @@ -1554,7 +1554,7 @@ mlir::Value CIRGenFunction::emitCXXNewExpr(const CXXNewExpr *E) { // Reset insertion point to resume back to post ifOp. if (postIfBody.isSet()) { - builder.create(loc); + cir::YieldOp::create(builder, loc); builder.restoreInsertionPoint(postIfBody); } } diff --git a/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp b/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp index 0633b62793eb..b62814d1352d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp @@ -342,23 +342,22 @@ class ComplexExprEmitter : public StmtVisitor { Expr *cond = E->getCond()->IgnoreParens(); mlir::Value condValue = CGF.evaluateExprAsBool(cond); - return Builder - .create( - loc, condValue, - /*thenBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - eval.begin(CGF); - mlir::Value trueValue = Visit(E->getTrueExpr()); - b.create(loc, trueValue); - eval.end(CGF); - }, - /*elseBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - eval.begin(CGF); - mlir::Value falseValue = Visit(E->getFalseExpr()); - b.create(loc, falseValue); - eval.end(CGF); - }) + return cir::TernaryOp::create( + Builder, loc, condValue, + /*thenBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + eval.begin(CGF); + mlir::Value trueValue = Visit(E->getTrueExpr()); + cir::YieldOp::create(b, loc, trueValue); + eval.end(CGF); + }, + /*elseBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + eval.begin(CGF); + mlir::Value falseValue = Visit(E->getFalseExpr()); + cir::YieldOp::create(b, loc, falseValue); + eval.end(CGF); + }) .getResult(); } diff --git a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp index dc697b4985ca..0e5a403968f2 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprConst.cpp @@ -1991,7 +1991,8 @@ mlir::Attribute ConstantEmitter::tryEmitPrivate(const APValue &Value, if (!C) return {}; - assert(mlir::isa(C) && "This should always be a TypedAttr."); + assert(mlir::isa(C) && + "This should always be a TypedAttr."); auto CTyped = mlir::cast(C); if (I == 0) @@ -2115,20 +2116,20 @@ mlir::Value CIRGenModule::emitMemberPointerConstant(const UnaryOperator *E) { if (const auto *methodDecl = dyn_cast(decl)) { auto ty = mlir::cast(convertType(E->getType())); if (methodDecl->isVirtual()) - return builder.create( - loc, getCXXABI().buildVirtualMethodAttr(ty, methodDecl)); + return cir::ConstantOp::create( + builder, loc, getCXXABI().buildVirtualMethodAttr(ty, methodDecl)); auto methodFuncOp = GetAddrOfFunction(methodDecl); - return builder.create( - loc, builder.getMethodAttr(ty, methodFuncOp)); + return cir::ConstantOp::create(builder, loc, + builder.getMethodAttr(ty, methodFuncOp)); } auto ty = mlir::cast(convertType(E->getType())); // Otherwise, a member data pointer. const auto *fieldDecl = cast(decl); - return builder.create( - loc, builder.getDataMemberAttr(ty, fieldDecl->getFieldIndex())); + return cir::ConstantOp::create( + builder, loc, builder.getDataMemberAttr(ty, fieldDecl->getFieldIndex())); } mlir::Attribute ConstantEmitter::emitAbstract(const Expr *E, diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp index 510e33d51084..2ae8c0d10703 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp @@ -189,14 +189,14 @@ class ScalarExprEmitter : public StmtVisitor { mlir::Value VisitFloatingLiteral(const FloatingLiteral *E) { mlir::Type Ty = CGF.convertType(E->getType()); assert(mlir::isa(Ty) && "expect floating-point type"); - return Builder.create(CGF.getLoc(E->getExprLoc()), - cir::FPAttr::get(Ty, E->getValue())); + return cir::ConstantOp::create(Builder, CGF.getLoc(E->getExprLoc()), + cir::FPAttr::get(Ty, E->getValue())); } mlir::Value VisitCharacterLiteral(const CharacterLiteral *E) { mlir::Type Ty = CGF.convertType(E->getType()); auto loc = CGF.getLoc(E->getExprLoc()); auto init = cir::IntAttr::get(Ty, E->getValue()); - return Builder.create(loc, init); + return cir::ConstantOp::create(Builder, loc, init); } mlir::Value VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) { llvm_unreachable("NYI"); @@ -310,8 +310,9 @@ class ScalarExprEmitter : public StmtVisitor { // operation. mlir::Value VecValue = Visit(E->getBase()); mlir::Value IndexValue = Visit(E->getIdx()); - return CGF.builder.create( - CGF.getLoc(E->getSourceRange()), VecValue, IndexValue); + return cir::VecExtractOp::create(CGF.getBuilder(), + CGF.getLoc(E->getSourceRange()), + VecValue, IndexValue); } // Just load the lvalue formed by the subscript expression. @@ -326,8 +327,9 @@ class ScalarExprEmitter : public StmtVisitor { // The undocumented form of __builtin_shufflevector. mlir::Value InputVec = Visit(E->getExpr(0)); mlir::Value IndexVec = Visit(E->getExpr(1)); - return CGF.builder.create( - CGF.getLoc(E->getSourceRange()), InputVec, IndexVec); + return cir::VecShuffleDynamicOp::create(CGF.getBuilder(), + CGF.getLoc(E->getSourceRange()), + InputVec, IndexVec); } else { // The documented form of __builtin_shufflevector, where the indices are // a variable number of integer constants. The constants will be stored @@ -342,9 +344,10 @@ class ScalarExprEmitter : public StmtVisitor { ->EvaluateKnownConstInt(CGF.getContext()) .getSExtValue())); } - return CGF.builder.create( - CGF.getLoc(E->getSourceRange()), CGF.convertType(E->getType()), Vec1, - Vec2, CGF.builder.getArrayAttr(Indices)); + return cir::VecShuffleOp::create(CGF.getBuilder(), + CGF.getLoc(E->getSourceRange()), + CGF.convertType(E->getType()), Vec1, + Vec2, CGF.builder.getArrayAttr(Indices)); } } mlir::Value VisitConvertVectorExpr(ConvertVectorExpr *E) { @@ -502,11 +505,11 @@ class ScalarExprEmitter : public StmtVisitor { auto &builder = CGF.getBuilder(); auto amt = builder.getSInt32(amount, loc); if (CGF.getLangOpts().isSignedOverflowDefined()) { - value = builder.create(loc, value.getType(), value, - amt); + value = cir::PtrStrideOp::create(builder, loc, value.getType(), value, + amt); } else { - value = builder.create(loc, value.getType(), value, - amt); + value = cir::PtrStrideOp::create(builder, loc, value.getType(), value, + amt); assert(!cir::MissingFeatures::emitCheckedInBoundsGEP()); } } @@ -691,9 +694,9 @@ class ScalarExprEmitter : public StmtVisitor { mlir::Value emitUnaryOp(const UnaryOperator *E, cir::UnaryOpKind kind, mlir::Value input, bool nsw = false) { - return Builder.create( - CGF.getLoc(E->getSourceRange().getBegin()), input.getType(), kind, - input, nsw); + return cir::UnaryOp::create(Builder, + CGF.getLoc(E->getSourceRange().getBegin()), + input.getType(), kind, input, nsw); } // C++ @@ -968,9 +971,9 @@ class ScalarExprEmitter : public StmtVisitor { // Other kinds of vectors. Element-wise comparison returning // a vector. cir::CmpOpKind Kind = ClangCmpToCIRCmp(E->getOpcode()); - Result = Builder.create( - CGF.getLoc(BOInfo.Loc), CGF.convertType(BOInfo.FullType), Kind, - BOInfo.LHS, BOInfo.RHS); + Result = cir::VecCmpOp::create(Builder, CGF.getLoc(BOInfo.Loc), + CGF.convertType(BOInfo.FullType), Kind, + BOInfo.LHS, BOInfo.RHS); } } else if (BOInfo.isFixedPointOp()) { assert(0 && "not implemented"); @@ -998,8 +1001,8 @@ class ScalarExprEmitter : public StmtVisitor { mlir::Value emitFloatToBoolConversion(mlir::Value src, mlir::Location loc) { auto boolTy = Builder.getBoolTy(); - return Builder.create(loc, boolTy, - cir::CastKind::float_to_bool, src); + return cir::CastOp::create(Builder, loc, boolTy, + cir::CastKind::float_to_bool, src); } mlir::Value emitIntToBoolConversion(mlir::Value srcVal, mlir::Location loc) { @@ -1009,8 +1012,8 @@ class ScalarExprEmitter : public StmtVisitor { // TODO: optimize this common case here or leave it for later // CIR passes? mlir::Type boolTy = CGF.convertType(CGF.getContext().BoolTy); - return Builder.create(loc, boolTy, cir::CastKind::int_to_bool, - srcVal); + return cir::CastOp::create(Builder, loc, boolTy, cir::CastKind::int_to_bool, + srcVal); } /// Convert the specified expression value to a boolean (!cir.bool) truth @@ -1342,8 +1345,9 @@ static mlir::Value emitPointerArithmetic(CIRGenFunction &CGF, index = CGF.getBuilder().createMul(index, numElements); if (CGF.getLangOpts().isSignedOverflowDefined()) { - pointer = CGF.getBuilder().create( - CGF.getLoc(op.E->getExprLoc()), pointer.getType(), pointer, index); + pointer = cir::PtrStrideOp::create(CGF.getBuilder(), + CGF.getLoc(op.E->getExprLoc()), + pointer.getType(), pointer, index); } else { pointer = CGF.emitCheckedInBoundsGEP(elemTy, pointer, index, isSigned, isSubtraction, op.E->getExprLoc()); @@ -1360,8 +1364,9 @@ static mlir::Value emitPointerArithmetic(CIRGenFunction &CGF, elemTy = CGF.convertTypeForMem(elementType); if (CGF.getLangOpts().isSignedOverflowDefined()) - return CGF.getBuilder().create( - CGF.getLoc(op.E->getExprLoc()), pointer.getType(), pointer, index); + return cir::PtrStrideOp::create(CGF.getBuilder(), + CGF.getLoc(op.E->getExprLoc()), + pointer.getType(), pointer, index); return CGF.emitCheckedInBoundsGEP(elemTy, pointer, index, isSigned, isSubtraction, op.E->getExprLoc()); @@ -1400,19 +1405,19 @@ mlir::Value ScalarExprEmitter::emitMul(const BinOpInfo &Ops) { if (Ops.isFixedPointOp()) llvm_unreachable("NYI"); - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Mul, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::Mul, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitDiv(const BinOpInfo &Ops) { - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Div, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::Div, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitRem(const BinOpInfo &Ops) { - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Rem, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::Rem, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitAdd(const BinOpInfo &Ops) { @@ -1453,9 +1458,9 @@ mlir::Value ScalarExprEmitter::emitAdd(const BinOpInfo &Ops) { if (Ops.isFixedPointOp()) llvm_unreachable("NYI"); - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Add, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::Add, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &Ops) { @@ -1496,9 +1501,9 @@ mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &Ops) { if (Ops.isFixedPointOp()) llvm_unreachable("NYI"); - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Sub, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), + cir::BinOpKind::Sub, Ops.LHS, Ops.RHS); } // If the RHS is not a pointer, then we have normal pointer @@ -1515,8 +1520,8 @@ mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &Ops) { // // See more in `EmitSub` in CGExprScalar.cpp. assert(!cir::MissingFeatures::llvmLoweringPtrDiffConsidersPointee()); - return Builder.create(CGF.getLoc(Ops.Loc), CGF.PtrDiffTy, - Ops.LHS, Ops.RHS); + return cir::PtrDiffOp::create(Builder, CGF.getLoc(Ops.Loc), CGF.PtrDiffTy, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitShl(const BinOpInfo &Ops) { @@ -1546,9 +1551,9 @@ mlir::Value ScalarExprEmitter::emitShl(const BinOpInfo &Ops) { llvm_unreachable("NYI"); } - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), Ops.LHS, - Ops.RHS, CGF.getBuilder().getUnitAttr()); + return cir::ShiftOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), Ops.LHS, Ops.RHS, + CGF.getBuilder().getUnitAttr()); } mlir::Value ScalarExprEmitter::emitShr(const BinOpInfo &Ops) { @@ -1570,24 +1575,24 @@ mlir::Value ScalarExprEmitter::emitShr(const BinOpInfo &Ops) { // Note that we don't need to distinguish unsigned treatment at this // point since it will be handled later by LLVM lowering. - return Builder.create( - CGF.getLoc(Ops.Loc), CGF.convertType(Ops.FullType), Ops.LHS, Ops.RHS); + return cir::ShiftOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitAnd(const BinOpInfo &Ops) { - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::And, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::And, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitXor(const BinOpInfo &Ops) { - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Xor, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::Xor, + Ops.LHS, Ops.RHS); } mlir::Value ScalarExprEmitter::emitOr(const BinOpInfo &Ops) { - return Builder.create(CGF.getLoc(Ops.Loc), - CGF.convertType(Ops.FullType), - cir::BinOpKind::Or, Ops.LHS, Ops.RHS); + return cir::BinOp::create(Builder, CGF.getLoc(Ops.Loc), + CGF.convertType(Ops.FullType), cir::BinOpKind::Or, + Ops.LHS, Ops.RHS); } // Emit code for an explicit or implicit cast. Implicit @@ -1793,16 +1798,16 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { if (E->getType()->isMemberFunctionPointerType()) { if (Kind == CK_BaseToDerivedMemberPointer) - return Builder.create(loc, resultTy, src, - offsetAttr); - return Builder.create(loc, resultTy, src, offsetAttr); + return cir::DerivedMethodOp::create(Builder, loc, resultTy, src, + offsetAttr); + return cir::BaseMethodOp::create(Builder, loc, resultTy, src, offsetAttr); } if (Kind == CK_BaseToDerivedMemberPointer) - return Builder.create(loc, resultTy, src, - offsetAttr); - return Builder.create(loc, resultTy, src, - offsetAttr); + return cir::DerivedDataMemberOp::create(Builder, loc, resultTy, src, + offsetAttr); + return cir::BaseDataMemberOp::create(Builder, loc, resultTy, src, + offsetAttr); } case CK_ARCProduceObject: llvm_unreachable("NYI"); @@ -1867,8 +1872,9 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { case CK_VectorSplat: { // Create a vector object and fill all elements with the same scalar value. assert(DestTy->isVectorType() && "CK_VectorSplat to non-vector type"); - return CGF.getBuilder().create( - CGF.getLoc(E->getSourceRange()), CGF.convertType(DestTy), Visit(E)); + return cir::VecSplatOp::create(CGF.getBuilder(), + CGF.getLoc(E->getSourceRange()), + CGF.convertType(DestTy), Visit(E)); } case CK_FixedPointCast: llvm_unreachable("NYI"); @@ -2031,15 +2037,16 @@ mlir::Value ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { } // Zero-initialize any remaining values. if (NumInitElements < VectorType.getSize()) { - mlir::Value ZeroValue = CGF.getBuilder().create( - CGF.getLoc(E->getSourceRange()), + mlir::Value ZeroValue = cir::ConstantOp::create( + CGF.getBuilder(), CGF.getLoc(E->getSourceRange()), CGF.getBuilder().getZeroInitAttr(VectorType.getElementType())); for (uint64_t i = NumInitElements; i < VectorType.getSize(); ++i) { Elements.push_back(ZeroValue); } } - return CGF.getBuilder().create( - CGF.getLoc(E->getSourceRange()), VectorType, Elements); + return cir::VecCreateOp::create(CGF.getBuilder(), + CGF.getLoc(E->getSourceRange()), VectorType, + Elements); } if (NumInitElements == 0) { @@ -2129,7 +2136,8 @@ mlir::Value ScalarExprEmitter::emitScalarCast(mlir::Value Src, QualType SrcType, ScalarConversionOpts Opts) { assert(!SrcType->isMatrixType() && !DstType->isMatrixType() && "Internal error: matrix types not handled by this function."); - if (mlir::isa(SrcTy) || mlir::isa(DstTy)) + if (mlir::isa(SrcTy) || + mlir::isa(DstTy)) llvm_unreachable("Obsolete code. Don't use mlir::IntegerType with CIR."); mlir::Type FullDstTy = DstTy; @@ -2183,7 +2191,7 @@ mlir::Value ScalarExprEmitter::emitScalarCast(mlir::Value Src, QualType SrcType, } assert(CastKind.has_value() && "Internal error: CastKind not set."); - return Builder.create(Src.getLoc(), FullDstTy, *CastKind, Src); + return cir::CastOp::create(Builder, Src.getLoc(), FullDstTy, *CastKind, Src); } LValue @@ -2407,8 +2415,8 @@ mlir::Value ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) { auto scopeLoc = CGF.getLoc(E->getSourceRange()); auto &builder = CGF.builder; - auto scope = builder.create( - scopeLoc, /*scopeBuilder=*/ + auto scope = cir::ScopeOp::create( + builder, scopeLoc, /*scopeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Type &yieldTy, mlir::Location loc) { CIRGenFunction::LexicalScope lexScope{CGF, loc, builder.getInsertionBlock()}; @@ -2418,7 +2426,7 @@ mlir::Value ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) { // evaluation through the shared cleanup block. We do not pass {&V} to // ForceCleanup, because the scope returns an rvalue. lexScope.ForceCleanup(); - builder.create(loc, scopeYieldVal); + cir::YieldOp::create(builder, loc, scopeYieldVal); yieldTy = scopeYieldVal.getType(); } }); @@ -2545,8 +2553,8 @@ mlir::Value ScalarExprEmitter::VisitAbstractConditionalOperator( mlir::Value condValue = Visit(condExpr); mlir::Value lhsValue = Visit(lhsExpr); mlir::Value rhsValue = Visit(rhsExpr); - return builder.create(loc, condValue, lhsValue, - rhsValue); + return cir::VecTernaryOp::create(builder, loc, condValue, lhsValue, + rhsValue); } // If this is a really simple expression (like x ? 4 : 5), emit this as a @@ -2592,50 +2600,49 @@ mlir::Value ScalarExprEmitter::VisitAbstractConditionalOperator( // Block does not return: build empty yield. if (mlir::isa(yieldTy)) { - builder.create(loc); + cir::YieldOp::create(builder, loc); } else { // Block returns: set null yield value. mlir::Value op0 = builder.getNullValue(yieldTy, loc); - builder.create(loc, op0); + cir::YieldOp::create(builder, loc, op0); } } }; - return builder - .create( - loc, condV, /*trueBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - assert(!cir::MissingFeatures::incrementProfileCounter()); - eval.begin(CGF); - auto lhs = Visit(lhsExpr); - eval.end(CGF); - - if (lhs) { - yieldTy = lhs.getType(); - b.create(loc, lhs); - return; - } - // If LHS or RHS is a throw or void expression we need to patch arms - // as to properly match yield types. - insertPoints.push_back(b.saveInsertionPoint()); - }, - /*falseBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - assert(!cir::MissingFeatures::incrementProfileCounter()); - eval.begin(CGF); - auto rhs = Visit(rhsExpr); - eval.end(CGF); - - if (rhs) { - yieldTy = rhs.getType(); - b.create(loc, rhs); - } else { - // If LHS or RHS is a throw or void expression we need to patch - // arms as to properly match yield types. - insertPoints.push_back(b.saveInsertionPoint()); - } - - patchVoidOrThrowSites(); - }) + return cir::TernaryOp::create( + builder, loc, condV, /*trueBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + assert(!cir::MissingFeatures::incrementProfileCounter()); + eval.begin(CGF); + auto lhs = Visit(lhsExpr); + eval.end(CGF); + + if (lhs) { + yieldTy = lhs.getType(); + cir::YieldOp::create(b, loc, lhs); + return; + } + // If LHS or RHS is a throw or void expression we need to patch + // arms as to properly match yield types. + insertPoints.push_back(b.saveInsertionPoint()); + }, + /*falseBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + assert(!cir::MissingFeatures::incrementProfileCounter()); + eval.begin(CGF); + auto rhs = Visit(rhsExpr); + eval.end(CGF); + + if (rhs) { + yieldTy = rhs.getType(); + cir::YieldOp::create(b, loc, rhs); + } else { + // If LHS or RHS is a throw or void expression we need to patch + // arms as to properly match yield types. + insertPoints.push_back(b.saveInsertionPoint()); + } + + patchVoidOrThrowSites(); + }) .getResult(); } @@ -2677,38 +2684,39 @@ mlir::Value ScalarExprEmitter::VisitBinLAnd(const clang::BinaryOperator *E) { CIRGenFunction::ConditionalEvaluation eval(CGF); mlir::Value LHSCondV = CGF.evaluateExprAsBool(E->getLHS()); - auto ResOp = Builder.create( - Loc, LHSCondV, /*trueBuilder=*/ + auto ResOp = cir::TernaryOp::create( + Builder, Loc, LHSCondV, /*trueBuilder=*/ [&](mlir::OpBuilder &B, mlir::Location Loc) { CIRGenFunction::LexicalScope LexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); mlir::Value RHSCondV = CGF.evaluateExprAsBool(E->getRHS()); - auto res = B.create( - Loc, RHSCondV, /*trueBuilder*/ + auto res = cir::TernaryOp::create( + B, Loc, RHSCondV, /*trueBuilder*/ [&](mlir::OpBuilder &B, mlir::Location Loc) { CIRGenFunction::LexicalScope lexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); - auto res = B.create(Loc, Builder.getTrueAttr()); - B.create(Loc, res.getRes()); + auto res = cir::ConstantOp::create(B, Loc, Builder.getTrueAttr()); + cir::YieldOp::create(B, Loc, res.getRes()); }, /*falseBuilder*/ [&](mlir::OpBuilder &b, mlir::Location Loc) { CIRGenFunction::LexicalScope lexScope{CGF, Loc, b.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); - auto res = b.create(Loc, Builder.getFalseAttr()); - b.create(Loc, res.getRes()); + auto res = + cir::ConstantOp::create(b, Loc, Builder.getFalseAttr()); + cir::YieldOp::create(b, Loc, res.getRes()); }); LexScope.ForceCleanup(); - B.create(Loc, res.getResult()); + cir::YieldOp::create(B, Loc, res.getResult()); }, /*falseBuilder*/ [&](mlir::OpBuilder &B, mlir::Location Loc) { CIRGenFunction::LexicalScope lexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); - auto res = B.create(Loc, Builder.getFalseAttr()); - B.create(Loc, res.getRes()); + auto res = cir::ConstantOp::create(B, Loc, Builder.getFalseAttr()); + cir::YieldOp::create(B, Loc, res.getRes()); }); return Builder.createZExtOrBitCast(ResOp.getLoc(), ResOp.getResult(), ResTy); } @@ -2748,21 +2756,21 @@ mlir::Value ScalarExprEmitter::VisitBinLOr(const clang::BinaryOperator *E) { CIRGenFunction::ConditionalEvaluation eval(CGF); mlir::Value LHSCondV = CGF.evaluateExprAsBool(E->getLHS()); - auto ResOp = Builder.create( - Loc, LHSCondV, /*trueBuilder=*/ + auto ResOp = cir::TernaryOp::create( + Builder, Loc, LHSCondV, /*trueBuilder=*/ [&](mlir::OpBuilder &B, mlir::Location Loc) { CIRGenFunction::LexicalScope lexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); - auto res = B.create(Loc, Builder.getTrueAttr()); - B.create(Loc, res.getRes()); + auto res = cir::ConstantOp::create(B, Loc, Builder.getTrueAttr()); + cir::YieldOp::create(B, Loc, res.getRes()); }, /*falseBuilder*/ [&](mlir::OpBuilder &B, mlir::Location Loc) { CIRGenFunction::LexicalScope LexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); mlir::Value RHSCondV = CGF.evaluateExprAsBool(E->getRHS()); - auto res = B.create( - Loc, RHSCondV, /*trueBuilder*/ + auto res = cir::TernaryOp::create( + B, Loc, RHSCondV, /*trueBuilder*/ [&](mlir::OpBuilder &B, mlir::Location Loc) { SmallVector Locs; if (mlir::isa(Loc)) { @@ -2776,8 +2784,8 @@ mlir::Value ScalarExprEmitter::VisitBinLOr(const clang::BinaryOperator *E) { CIRGenFunction::LexicalScope lexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); - auto res = B.create(Loc, Builder.getTrueAttr()); - B.create(Loc, res.getRes()); + auto res = cir::ConstantOp::create(B, Loc, Builder.getTrueAttr()); + cir::YieldOp::create(B, Loc, res.getRes()); }, /*falseBuilder*/ [&](mlir::OpBuilder &b, mlir::Location Loc) { @@ -2793,11 +2801,12 @@ mlir::Value ScalarExprEmitter::VisitBinLOr(const clang::BinaryOperator *E) { CIRGenFunction::LexicalScope lexScope{CGF, Loc, B.getInsertionBlock()}; CGF.currLexScope->setAsTernary(); - auto res = b.create(Loc, Builder.getFalseAttr()); - b.create(Loc, res.getRes()); + auto res = + cir::ConstantOp::create(b, Loc, Builder.getFalseAttr()); + cir::YieldOp::create(b, Loc, res.getRes()); }); LexScope.ForceCleanup(); - B.create(Loc, res.getResult()); + cir::YieldOp::create(B, Loc, res.getResult()); }); return Builder.createZExtOrBitCast(ResOp.getLoc(), ResOp.getResult(), ResTy); @@ -2858,15 +2867,15 @@ mlir::Value CIRGenFunction::emitCheckedInBoundsGEP( bool SignedIndices, bool IsSubtraction, SourceLocation Loc) { mlir::Type PtrTy = Ptr.getType(); assert(IdxList.size() == 1 && "multi-index ptr arithmetic NYI"); - mlir::Value GEPVal = - builder.create(CGM.getLoc(Loc), PtrTy, Ptr, IdxList[0]); + mlir::Value GEPVal = cir::PtrStrideOp::create(builder, CGM.getLoc(Loc), PtrTy, + Ptr, IdxList[0]); // If the pointer overflow sanitizer isn't enabled, do nothing. if (!SanOpts.has(SanitizerKind::PointerOverflow)) { cir::GEPNoWrapFlags nwFlags = cir::GEPNoWrapFlags::inbounds; if (!SignedIndices && !IsSubtraction) nwFlags = nwFlags | cir::GEPNoWrapFlags::nuw; - return builder.create(CGM.getLoc(Loc), PtrTy, Ptr, - IdxList[0], nwFlags); + return cir::PtrStrideOp::create(builder, CGM.getLoc(Loc), PtrTy, Ptr, + IdxList[0], nwFlags); } return GEPVal; diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp index 7274fd3175cc..53cf0f5edd1c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp @@ -369,11 +369,11 @@ void CIRGenFunction::LexicalScope::cleanup() { // If we now have one after `applyCleanup`, hook it up properly. if (!cleanupBlock && localScope->getCleanupBlock(builder)) { cleanupBlock = localScope->getCleanupBlock(builder); - builder.create(insPt->back().getLoc(), cleanupBlock); + BrOp::create(builder, insPt->back().getLoc(), cleanupBlock); if (!cleanupBlock->mightHaveTerminator()) { mlir::OpBuilder::InsertionGuard guard(builder); builder.setInsertionPointToEnd(cleanupBlock); - builder.create(localScope->EndLoc); + YieldOp::create(builder, localScope->EndLoc); } } @@ -398,7 +398,7 @@ void CIRGenFunction::LexicalScope::cleanup() { brOp.setSuccessor(cleanupBlock); } } - builder.create(loc, retBlock); + BrOp::create(builder, loc, retBlock); return; } } @@ -410,8 +410,8 @@ void CIRGenFunction::LexicalScope::cleanup() { // Ternary ops have to deal with matching arms for yielding types // and do return a value, it must do its own cir.yield insertion. if (!localScope->isTernary() && !insPt->mightHaveTerminator()) { - !retVal ? builder.create(localScope->EndLoc) - : builder.create(localScope->EndLoc, retVal); + !retVal ? YieldOp::create(builder, localScope->EndLoc) + : YieldOp::create(builder, localScope->EndLoc, retVal); } }; @@ -452,7 +452,7 @@ void CIRGenFunction::LexicalScope::cleanup() { // If there's a cleanup block, branch to it, nothing else to do. if (cleanupBlock) { - builder.create(currBlock->back().getLoc(), cleanupBlock); + BrOp::create(builder, currBlock->back().getLoc(), cleanupBlock); return; } @@ -472,10 +472,10 @@ cir::ReturnOp CIRGenFunction::LexicalScope::emitReturn(mlir::Location loc) { if (CGF.FnRetCIRTy.has_value()) { // If there's anything to return, load it first. - auto val = builder.create(loc, *CGF.FnRetCIRTy, *CGF.FnRetAlloca); - return builder.create(loc, llvm::ArrayRef(val.getResult())); + auto val = LoadOp::create(builder, loc, *CGF.FnRetCIRTy, *CGF.FnRetAlloca); + return ReturnOp::create(builder, loc, llvm::ArrayRef(val.getResult())); } - return builder.create(loc); + return ReturnOp::create(builder, loc); } void CIRGenFunction::LexicalScope::emitImplicitReturn() { @@ -502,14 +502,14 @@ void CIRGenFunction::LexicalScope::emitImplicitReturn() { llvm_unreachable("NYI"); } else if (shouldEmitUnreachable) { if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0) { - builder.create(localScope->EndLoc); + cir::TrapOp::create(builder, localScope->EndLoc); builder.clearInsertionPoint(); return; } } if (CGF.SanOpts.has(SanitizerKind::Return) || shouldEmitUnreachable) { - builder.create(localScope->EndLoc); + cir::UnreachableOp::create(builder, localScope->EndLoc); builder.clearInsertionPoint(); return; } @@ -863,8 +863,8 @@ cir::FuncOp CIRGenFunction::generateCode(clang::GlobalDecl gd, cir::FuncOp fn, mlir::Value CIRGenFunction::createLoad(const VarDecl *vd, const char *name) { auto addr = GetAddrOfLocalVar(vd); - return builder.create(getLoc(vd->getLocation()), - addr.getElementType(), addr.getPointer()); + return LoadOp::create(builder, getLoc(vd->getLocation()), + addr.getElementType(), addr.getPointer()); } void CIRGenFunction::emitConstructorBody(FunctionArgList &args) { @@ -2018,8 +2018,8 @@ mlir::Value CIRGenFunction::emitAlignmentAssumption( mlir::Value offsetValue) { if (SanOpts.has(SanitizerKind::Alignment)) llvm_unreachable("NYI"); - return builder.create(getLoc(assumptionLoc), ptrValue, - alignment, offsetValue); + return cir::AssumeAlignedOp::create(builder, getLoc(assumptionLoc), ptrValue, + alignment, offsetValue); } mlir::Value CIRGenFunction::emitAlignmentAssumption( diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h index 0a69fa61c4d2..2e8925f97b35 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.h +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h @@ -1869,8 +1869,9 @@ class CIRGenFunction : public CIRGenTypeCache { for (uint32_t i = 0; i < N; ++i) { args.push_back(emitScalarExpr(E->getArg(i))); } - const auto call = builder.create( - getLoc(E->getExprLoc()), builder.getStringAttr(Name), cirTy, args); + const auto call = cir::LLVMIntrinsicCallOp::create( + builder, getLoc(E->getExprLoc()), builder.getStringAttr(Name), cirTy, + args); return RValue::get(call->getResult(0)); } diff --git a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp index 3b95098eead2..5fbe7c097b2f 100644 --- a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp @@ -728,7 +728,7 @@ struct CallEndCatch final : EHScopeStack::Cleanup { // here. For CIR, just let it pass since the cleanup is going // to be emitted on a later pass when lowering the catch region. // CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM)); - CGF.getBuilder().create(*CGF.currSrcLoc); + cir::YieldOp::create(CGF.getBuilder(), *CGF.currSrcLoc); return; } @@ -737,7 +737,7 @@ struct CallEndCatch final : EHScopeStack::Cleanup { // to be emitted on a later pass when lowering the catch region. // CGF.EmitRuntimeCallOrTryCall(getEndCatchFn(CGF.CGM)); if (!CGF.getBuilder().getBlock()->mightHaveTerminator()) - CGF.getBuilder().create(*CGF.currSrcLoc); + cir::YieldOp::create(CGF.getBuilder(), *CGF.currSrcLoc); } }; } // namespace @@ -751,8 +751,9 @@ struct CallEndCatch final : EHScopeStack::Cleanup { /// \param EndMightThrow - true if __cxa_end_catch might throw static mlir::Value CallBeginCatch(CIRGenFunction &CGF, mlir::Type ParamTy, bool EndMightThrow) { - auto catchParam = CGF.getBuilder().create( - CGF.getBuilder().getUnknownLoc(), ParamTy, nullptr, nullptr); + auto catchParam = cir::CatchParamOp::create(CGF.getBuilder(), + CGF.getBuilder().getUnknownLoc(), + ParamTy, nullptr, nullptr); CGF.EHStack.pushCleanup( NormalAndEHCleanup, @@ -963,8 +964,8 @@ CIRGenCallee CIRGenItaniumCXXABI::getVirtualFunctionPointer( if (CGM.getItaniumVTableContext().isRelativeLayout()) { llvm_unreachable("NYI"); } else { - auto VTableSlotPtr = builder.create( - loc, builder.getPointerTo(TyPtr), VTable, VTableIndex); + auto VTableSlotPtr = cir::VTableGetVirtualFnAddrOp::create( + builder, loc, builder.getPointerTo(TyPtr), VTable, VTableIndex); VFuncLoad = builder.createAlignedLoad(loc, TyPtr, VTableSlotPtr, CGF.getPointerAlign()); } @@ -1023,8 +1024,8 @@ CIRGenItaniumCXXABI::getVTableAddressPoint(BaseSubobject Base, auto &builder = CGM.getBuilder(); auto vtablePtrTy = cir::VPtrType::get(builder.getContext()); - return builder.create( - CGM.getLoc(VTableClass->getSourceRange()), vtablePtrTy, + return cir::VTableAddrPointOp::create( + builder, CGM.getLoc(VTableClass->getSourceRange()), vtablePtrTy, mlir::FlatSymbolRefAttr::get(vtable.getSymNameAttr()), cir::AddressPointAttr::get(CGM.getBuilder().getContext(), AddressPoint.VTableIndex, @@ -2317,24 +2318,24 @@ void insertThrowAndSplit(mlir::OpBuilder &builder, mlir::Location loc, mlir::Region *region = currentBlock->getParent(); if (currentBlock->empty()) { - builder.create(loc, exceptionPtr, typeInfo, dtor); - builder.create(loc); + cir::ThrowOp::create(builder, loc, exceptionPtr, typeInfo, dtor); + cir::UnreachableOp::create(builder, loc); } else { mlir::Block *throwBlock = builder.createBlock(region); - builder.create(loc, exceptionPtr, typeInfo, dtor); - builder.create(loc); + cir::ThrowOp::create(builder, loc, exceptionPtr, typeInfo, dtor); + cir::UnreachableOp::create(builder, loc); builder.setInsertionPointToEnd(currentBlock); - builder.create(loc, throwBlock); + cir::BrOp::create(builder, loc, throwBlock); } (void)builder.createBlock(region); // This will be erased during codegen, it acts as a placeholder for the // operations to be inserted (if any) - builder.create(loc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - b.create(loc); - }); + cir::ScopeOp::create(builder, loc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + cir::YieldOp::create(b, loc); + }); } void CIRGenItaniumCXXABI::emitRethrow(CIRGenFunction &CGF, bool isNoReturn) { @@ -2367,9 +2368,8 @@ void CIRGenItaniumCXXABI::emitThrow(CIRGenFunction &CGF, auto subExprLoc = CGF.getLoc(E->getSubExpr()->getSourceRange()); // Defer computing allocation size to some later lowering pass. auto exceptionPtr = - builder - .create(subExprLoc, throwTy, - builder.getI64IntegerAttr(typeSize)) + cir::AllocExceptionOp::create(builder, subExprLoc, throwTy, + builder.getI64IntegerAttr(typeSize)) .getAddr(); // Build expression and store its result into exceptionPtr. @@ -2428,9 +2428,9 @@ mlir::Value CIRGenItaniumCXXABI::getVirtualBaseClassOffset( BaseClassDecl); mlir::Value OffsetVal = CGF.getBuilder().getSInt64(VBaseOffsetOffset.getQuantity(), loc); - auto VBaseOffsetPtr = CGF.getBuilder().create( - loc, CGM.UInt8PtrTy, VTableBytePtr, - OffsetVal); // vbase.offset.ptr + auto VBaseOffsetPtr = cir::PtrStrideOp::create(CGF.getBuilder(), loc, + CGM.UInt8PtrTy, VTableBytePtr, + OffsetVal); // vbase.offset.ptr mlir::Value VBaseOffset; if (CGM.getItaniumVTableContext().isRelativeLayout()) { @@ -2463,7 +2463,7 @@ static void emitCallToBadCast(CIRGenFunction &CGF, mlir::Location loc) { assert(!cir::MissingFeatures::setCallingConv()); CGF.emitRuntimeCall(loc, getBadCastFn(CGF)); - CGF.getBuilder().create(loc); + cir::UnreachableOp::create(CGF.getBuilder(), loc); CGF.getBuilder().clearInsertionPoint(); } @@ -2559,6 +2559,7 @@ static mlir::Value emitExactDynamicCast(CIRGenItaniumCXXABI &ABI, QualType DestRecordTy, cir::PointerType DestCIRTy, bool IsRefCast, Address Src) { + CIRGenBuilderTy &builder = CGF.getBuilder(); // Find all the inheritance paths from SrcRecordTy to DestRecordTy. const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl(); const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl(); @@ -2608,14 +2609,14 @@ static mlir::Value emitExactDynamicCast(CIRGenItaniumCXXABI &ABI, if (!Offset) { // If there are no public inheritance paths, the cast always fails. - mlir::Value NullPtrValue = CGF.getBuilder().getNullPtr(DestCIRTy, Loc); + mlir::Value NullPtrValue = builder.getNullPtr(DestCIRTy, Loc); if (IsRefCast) { - auto *CurrentRegion = CGF.getBuilder().getBlock()->getParent(); + auto *CurrentRegion = builder.getBlock()->getParent(); emitCallToBadCast(CGF, Loc); // The call to bad_cast will terminate the block. Create a new block to // hold any follow up code. - CGF.getBuilder().createBlock(CurrentRegion, CurrentRegion->end()); + builder.createBlock(CurrentRegion, CurrentRegion->end()); } return NullPtrValue; @@ -2632,57 +2633,52 @@ static mlir::Value emitExactDynamicCast(CIRGenItaniumCXXABI &ABI, // TODO(cir): handle address space here. assert(!cir::MissingFeatures::addressSpace()); mlir::Type VPtrTy = ExpectedVPtr.getType(); - mlir::Type VPtrPtrTy = CGF.getBuilder().getPointerTo(VPtrTy); - Address SrcVPtrPtr( - CGF.getBuilder().createBitcast(Src.getPointer(), VPtrPtrTy), - Src.getAlignment()); - mlir::Value SrcVPtr = CGF.getBuilder().createLoad(Loc, SrcVPtrPtr); + mlir::Type VPtrPtrTy = builder.getPointerTo(VPtrTy); + Address SrcVPtrPtr(builder.createBitcast(Src.getPointer(), VPtrPtrTy), + Src.getAlignment()); + mlir::Value SrcVPtr = builder.createLoad(Loc, SrcVPtrPtr); // TODO(cir): decorate SrcVPtr with TBAA info. assert(!cir::MissingFeatures::tbaa()); - mlir::Value Success = CGF.getBuilder().createCompare(Loc, cir::CmpOpKind::eq, - SrcVPtr, ExpectedVPtr); + mlir::Value Success = + builder.createCompare(Loc, cir::CmpOpKind::eq, SrcVPtr, ExpectedVPtr); auto emitCastResult = [&] { if (Offset->isZero()) - return CGF.getBuilder().createBitcast(Src.getPointer(), DestCIRTy); + return builder.createBitcast(Src.getPointer(), DestCIRTy); // TODO(cir): handle address space here. assert(!cir::MissingFeatures::addressSpace()); - mlir::Type U8PtrTy = - CGF.getBuilder().getPointerTo(CGF.getBuilder().getUInt8Ty()); - - mlir::Value StrideToApply = CGF.getBuilder().getConstInt( - Loc, CGF.getBuilder().getUInt64Ty(), Offset->getQuantity()); - mlir::Value SrcU8Ptr = - CGF.getBuilder().createBitcast(Src.getPointer(), U8PtrTy); - mlir::Value ResultU8Ptr = CGF.getBuilder().create( - Loc, U8PtrTy, SrcU8Ptr, StrideToApply); - return CGF.getBuilder().createBitcast(ResultU8Ptr, DestCIRTy); + mlir::Type U8PtrTy = builder.getPointerTo(builder.getUInt8Ty()); + + mlir::Value StrideToApply = + builder.getConstInt(Loc, builder.getUInt64Ty(), Offset->getQuantity()); + mlir::Value SrcU8Ptr = builder.createBitcast(Src.getPointer(), U8PtrTy); + mlir::Value ResultU8Ptr = cir::PtrStrideOp::create(builder, Loc, U8PtrTy, + SrcU8Ptr, StrideToApply); + return builder.createBitcast(ResultU8Ptr, DestCIRTy); }; if (IsRefCast) { - mlir::Value Failed = CGF.getBuilder().createNot(Success); - CGF.getBuilder().create(Loc, Failed, /*withElseRegion=*/false, - [&](mlir::OpBuilder &, mlir::Location) { - emitCallToBadCast(CGF, Loc); - }); + mlir::Value Failed = builder.createNot(Success); + cir::IfOp::create(builder, Loc, Failed, /*withElseRegion=*/false, + [&](mlir::OpBuilder &, mlir::Location) { + emitCallToBadCast(CGF, Loc); + }); return emitCastResult(); } - return CGF.getBuilder() - .create( - Loc, Success, - [&](mlir::OpBuilder &, mlir::Location) { - auto Result = emitCastResult(); - CGF.getBuilder().createYield(Loc, Result); - }, - [&](mlir::OpBuilder &, mlir::Location) { - mlir::Value NullPtrValue = - CGF.getBuilder().getNullPtr(DestCIRTy, Loc); - CGF.getBuilder().createYield(Loc, NullPtrValue); - }) + return cir::TernaryOp::create( + builder, Loc, Success, + [&](mlir::OpBuilder &, mlir::Location) { + auto Result = emitCastResult(); + builder.createYield(Loc, Result); + }, + [&](mlir::OpBuilder &, mlir::Location) { + mlir::Value NullPtrValue = builder.getNullPtr(DestCIRTy, Loc); + builder.createYield(Loc, NullPtrValue); + }) .getResult(); } diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp index c2b43375e6e2..bdac32b9087c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp @@ -838,8 +838,8 @@ cir::GlobalOp CIRGenModule::createGlobalOp(CIRGenModule &cgm, if (curCGF) builder.setInsertionPoint(curCGF->CurFn); - g = builder.create(loc, name, t, isConstant, linkage, - addrSpace); + g = cir::GlobalOp::create(builder, loc, name, t, isConstant, linkage, + addrSpace); if (!curCGF) { if (insertPoint) cgm.getModule().insert(insertPoint, g); @@ -1040,7 +1040,7 @@ void CIRGenModule::replaceGlobal(cir::GlobalOp oldSym, cir::GlobalOp newSym) { auto ar = cast(init); mlir::OpBuilder::InsertionGuard guard(builder); builder.setInsertionPointAfter(c); - auto newUser = builder.create(c.getLoc(), ar); + auto newUser = cir::ConstantOp::create(builder, c.getLoc(), ar); c.replaceAllUsesWith(newUser.getOperation()); } } @@ -1282,8 +1282,8 @@ mlir::Value CIRGenModule::getAddrOfGlobalVar(const VarDecl *d, mlir::Type ty, bool tlsAccess = d->getTLSKind() != VarDecl::TLS_None; auto g = getOrCreateCIRGlobal(d, ty, isForDefinition); auto ptrTy = builder.getPointerTo(g.getSymType(), g.getAddrSpace()); - return builder.create(getLoc(d->getSourceRange()), ptrTy, - g.getSymName(), tlsAccess); + return cir::GetGlobalOp::create(builder, getLoc(d->getSourceRange()), ptrTy, + g.getSymName(), tlsAccess); } cir::GlobalViewAttr @@ -2715,7 +2715,7 @@ cir::FuncOp CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name, if (curCGF) builder.setInsertionPoint(curCGF->CurFn); - f = builder.create(loc, name, ty); + f = cir::FuncOp::create(builder, loc, name, ty); if (fd) f.setAstAttr(makeFuncDeclAttr(fd, &getMLIRContext())); diff --git a/clang/lib/CIR/CodeGen/CIRGenOpenMPRuntime.cpp b/clang/lib/CIR/CodeGen/CIRGenOpenMPRuntime.cpp index 526567f31715..ba15b91fb930 100644 --- a/clang/lib/CIR/CodeGen/CIRGenOpenMPRuntime.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenOpenMPRuntime.cpp @@ -66,7 +66,7 @@ void CIRGenOpenMPRuntime::emitTaskWaitCall(CIRGenBuilderTy &builder, // TODO(cir): This could change in the near future when OpenMP 5.0 gets // supported by MLIR llvm_unreachable("NYI"); - // builder.create(Loc); + // mlir::omp::TaskwaitOp::create(builder, Loc); } else { llvm_unreachable("NYI"); } @@ -80,7 +80,7 @@ void CIRGenOpenMPRuntime::emitBarrierCall(CIRGenBuilderTy &builder, assert(!cir::MissingFeatures::openMPRegionInfo()); if (CGF.CGM.getLangOpts().OpenMPIRBuilder) { - builder.create(Loc); + mlir::omp::BarrierOp::create(builder, Loc); return; } @@ -98,7 +98,7 @@ void CIRGenOpenMPRuntime::emitTaskyieldCall(CIRGenBuilderTy &builder, return; if (CGF.CGM.getLangOpts().OpenMPIRBuilder) { - builder.create(Loc); + mlir::omp::TaskyieldOp::create(builder, Loc); } else { llvm_unreachable("NYI"); } diff --git a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp index fe1d88fe415a..081127931107 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp @@ -73,8 +73,8 @@ Address CIRGenFunction::emitCompoundStmt(const CompoundStmt &S, bool getLast, SymTableScopeTy varScope(symbolTable); auto scopeLoc = getLoc(S.getSourceRange()); mlir::OpBuilder::InsertPoint scopeInsPt; - builder.create( - scopeLoc, /*scopeBuilder=*/ + cir::ScopeOp::create( + builder, scopeLoc, /*scopeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Type &type, mlir::Location loc) { scopeInsPt = b.saveInsertionPoint(); }); @@ -388,8 +388,8 @@ CIRGenFunction::emitAttributedStmt(const AttributedStmt &S) { if (getLangOpts().CXXAssumptions && builder.getInsertionBlock() && !assumption->HasSideEffects(getContext())) { mlir::Value assumptionValue = emitCheckedArgForAssume(assumption); - builder.create(getLoc(S.getSourceRange()), - assumptionValue); + cir::AssumeOp::create(builder, getLoc(S.getSourceRange()), + assumptionValue); } break; } @@ -485,12 +485,12 @@ mlir::LogicalResult CIRGenFunction::emitIfStmt(const IfStmt &S) { // LexicalScope ConditionScope(*this, S.getCond()->getSourceRange()); // The if scope contains the full source range for IfStmt. auto scopeLoc = getLoc(S.getSourceRange()); - builder.create( - scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - LexicalScope lexScope{*this, scopeLoc, builder.getInsertionBlock()}; - res = ifStmtBuilder(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + LexicalScope lexScope{*this, scopeLoc, + builder.getInsertionBlock()}; + res = ifStmtBuilder(); + }); return res; } @@ -592,10 +592,10 @@ mlir::LogicalResult CIRGenFunction::emitReturnStmt(const ReturnStmt &S) { // dispatched by `handleReturnVal()` might needs to manipulate blocks and // look into parents, which are all unlinked. mlir::OpBuilder::InsertPoint scopeBody; - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - scopeBody = b.saveInsertionPoint(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + scopeBody = b.saveInsertionPoint(); + }); { mlir::OpBuilder::InsertionGuard guard(builder); builder.restoreInsertionPoint(scopeBody); @@ -626,8 +626,8 @@ mlir::LogicalResult CIRGenFunction::emitGotoStmt(const GotoStmt &S) { // info support just yet, look at this again once we have it. assert(builder.getInsertionBlock() && "not yet implemented"); - builder.create(getLoc(S.getSourceRange()), - S.getLabel()->getName()); + cir::GotoOp::create(builder, getLoc(S.getSourceRange()), + S.getLabel()->getName()); // A goto marks the end of a block, create a new one for codegen after // emitGotoStmt can resume building in that block. @@ -649,12 +649,12 @@ mlir::LogicalResult CIRGenFunction::emitLabel(const LabelDecl *D) { mlir::OpBuilder::InsertionGuard guard(builder); labelBlock = builder.createBlock(builder.getBlock()->getParent()); } - builder.create(getLoc(D->getSourceRange()), labelBlock); + BrOp::create(builder, getLoc(D->getSourceRange()), labelBlock); } builder.setInsertionPointToEnd(labelBlock); auto label = - builder.create(getLoc(D->getSourceRange()), D->getName()); + cir::LabelOp::create(builder, getLoc(D->getSourceRange()), D->getName()); builder.setInsertionPointToEnd(labelBlock); auto func = cast(CurFn); CGM.mapBlockAddress(cir::BlockAddrInfoAttr::get(builder.getContext(), @@ -759,7 +759,7 @@ CIRGenFunction::emitCaseDefaultCascade(const T *stmt, mlir::Type condType, auto *sub = stmt->getSubStmt(); mlir::OpBuilder::InsertPoint insertPoint; - builder.create(loc, value, kind, insertPoint); + CaseOp::create(builder, loc, value, kind, insertPoint); { mlir::OpBuilder::InsertionGuard guardSwitch(builder); @@ -915,16 +915,16 @@ CIRGenFunction::emitCXXForRangeStmt(const CXXForRangeStmt &S, auto res = mlir::success(); auto scopeLoc = getLoc(S.getSourceRange()); - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - // Create a cleanup scope for the condition - // variable cleanups. Logical equivalent from - // LLVM codegn for LexicalScope - // ConditionScope(*this, S.getSourceRange())... - LexicalScope lexScope{ - *this, loc, builder.getInsertionBlock()}; - res = forStmtBuilder(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + // Create a cleanup scope for the condition + // variable cleanups. Logical equivalent from + // LLVM codegn for LexicalScope + // ConditionScope(*this, S.getSourceRange())... + LexicalScope lexScope{*this, loc, + builder.getInsertionBlock()}; + res = forStmtBuilder(); + }); if (res.failed()) return res; @@ -967,7 +967,7 @@ mlir::LogicalResult CIRGenFunction::emitForStmt(const ForStmt &S) { // scalar type. condVal = evaluateExprAsBool(S.getCond()); } else { - condVal = b.create(loc, builder.getTrueAttr()); + condVal = cir::ConstantOp::create(b, loc, builder.getTrueAttr()); } builder.createCondition(condVal); }, @@ -991,12 +991,12 @@ mlir::LogicalResult CIRGenFunction::emitForStmt(const ForStmt &S) { auto res = mlir::success(); auto scopeLoc = getLoc(S.getSourceRange()); - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - LexicalScope lexScope{ - *this, loc, builder.getInsertionBlock()}; - res = forStmtBuilder(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + LexicalScope lexScope{*this, loc, + builder.getInsertionBlock()}; + res = forStmtBuilder(); + }); if (res.failed()) return res; @@ -1042,12 +1042,12 @@ mlir::LogicalResult CIRGenFunction::emitDoStmt(const DoStmt &S) { auto res = mlir::success(); auto scopeLoc = getLoc(S.getSourceRange()); - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - LexicalScope lexScope{ - *this, loc, builder.getInsertionBlock()}; - res = doStmtBuilder(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + LexicalScope lexScope{*this, loc, + builder.getInsertionBlock()}; + res = doStmtBuilder(); + }); if (res.failed()) return res; @@ -1098,12 +1098,12 @@ mlir::LogicalResult CIRGenFunction::emitWhileStmt(const WhileStmt &S) { auto res = mlir::success(); auto scopeLoc = getLoc(S.getSourceRange()); - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - LexicalScope lexScope{ - *this, loc, builder.getInsertionBlock()}; - res = whileStmtBuilder(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + LexicalScope lexScope{*this, loc, + builder.getInsertionBlock()}; + res = whileStmtBuilder(); + }); if (res.failed()) return res; @@ -1170,8 +1170,8 @@ mlir::LogicalResult CIRGenFunction::emitSwitchStmt(const SwitchStmt &S) { // TODO: if the switch has a condition wrapped by __builtin_unpredictable? auto res = mlir::success(); - swop = builder.create( - getLoc(S.getBeginLoc()), condV, + swop = SwitchOp::create( + builder, getLoc(S.getBeginLoc()), condV, /*switchBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc, mlir::OperationState &os) { currLexScope->setAsSwitch(); @@ -1189,12 +1189,12 @@ mlir::LogicalResult CIRGenFunction::emitSwitchStmt(const SwitchStmt &S) { // The switch scope contains the full source range for SwitchStmt. auto scopeLoc = getLoc(S.getSourceRange()); auto res = mlir::success(); - builder.create(scopeLoc, /*scopeBuilder=*/ - [&](mlir::OpBuilder &b, mlir::Location loc) { - LexicalScope lexScope{ - *this, loc, builder.getInsertionBlock()}; - res = switchStmtBuilder(); - }); + cir::ScopeOp::create(builder, scopeLoc, /*scopeBuilder=*/ + [&](mlir::OpBuilder &b, mlir::Location loc) { + LexicalScope lexScope{*this, loc, + builder.getInsertionBlock()}; + res = switchStmtBuilder(); + }); llvm::SmallVector cases; swop.collectCases(cases); diff --git a/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp b/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp index 5494268e9606..f0d037c63bd8 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmtOpenMP.cpp @@ -71,13 +71,13 @@ CIRGenFunction::emitOMPParallelDirective(const OMPParallelDirective &S) { mlir::LogicalResult res = mlir::success(); auto scopeLoc = getLoc(S.getSourceRange()); // Create a `omp.parallel` op. - auto parallelOp = builder.create(scopeLoc); + auto parallelOp = ParallelOp::create(builder, scopeLoc); mlir::Block &block = parallelOp.getRegion().emplaceBlock(); mlir::OpBuilder::InsertionGuard guardCase(builder); builder.setInsertionPointToEnd(&block); // Create a scope for the OpenMP region. - builder.create( - scopeLoc, /*scopeBuilder=*/ + cir::ScopeOp::create( + builder, scopeLoc, /*scopeBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { LexicalScope lexScope{*this, scopeLoc, builder.getInsertionBlock()}; // Emit the body of the region. @@ -88,7 +88,7 @@ CIRGenFunction::emitOMPParallelDirective(const OMPParallelDirective &S) { res = mlir::failure(); }); // Add the terminator for `omp.parallel`. - builder.create(getLoc(S.getSourceRange().getEnd())); + TerminatorOp::create(builder, getLoc(S.getSourceRange().getEnd())); return res; } diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index b174956b54cb..0417f6dfdc1e 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -139,8 +139,8 @@ Operation *cir::CIRDialect::materializeConstant(mlir::OpBuilder &builder, mlir::Attribute value, mlir::Type type, mlir::Location loc) { - return builder.create(loc, type, - mlir::cast(value)); + return cir::ConstantOp::create(builder, loc, type, + mlir::cast(value)); } //===----------------------------------------------------------------------===// @@ -229,7 +229,7 @@ LogicalResult ensureRegionTerm(OpAsmParser &parser, Region ®ion, // Terminator was omitted correctly: recreate it. builder.setInsertionPointToEnd(&block); - builder.create(eLoc); + cir::YieldOp::create(builder, eLoc); return success(); } @@ -442,7 +442,8 @@ static LogicalResult checkConstantTypes(mlir::Operation *op, mlir::Type opType, if (mlir::isa(attrType)) return success(); - assert(mlir::isa(attrType) && "What else could we be looking at here?"); + assert(mlir::isa(attrType) && + "What else could we be looking at here?"); return op->emitOpError("global with type ") << mlir::cast(attrType).getType() << " not supported"; } @@ -1466,7 +1467,7 @@ void cir::IfOp::print(OpAsmPrinter &p) { /// Default callback for IfOp builders. void cir::buildTerminatedBody(OpBuilder &builder, Location loc) { // add cir.yield to the end of the block - builder.create(loc); + cir::YieldOp::create(builder, loc); } /// Given the region at `index`, or the parent operation if `index` is None, @@ -3813,7 +3814,8 @@ LogicalResult cir::VTableAttr::verify( if (auto arrayElts = llvm::dyn_cast(constArrayAttr.getElts())) { arrayElts.walkImmediateSubElements( [&](Attribute attr) { - if (mlir::isa(attr) || mlir::isa(attr)) + if (mlir::isa(attr) || + mlir::isa(attr)) return; eltTypeCheck = emitError() << "expected GlobalViewAttr attribute"; @@ -4033,17 +4035,20 @@ void cir::InlineAsmOp::build(OpBuilder &odsBuilder, OperationState &odsState, segments.push_back(operandRange.size()); odsState.addOperands(operandRange); } - - odsState.addAttribute("operands_segments", - DenseI32ArrayAttr::get(odsBuilder.getContext(), segments)); + + odsState.addAttribute( + "operands_segments", + DenseI32ArrayAttr::get(odsBuilder.getContext(), segments)); odsState.addAttribute("asm_string", odsBuilder.getStringAttr(asm_string)); odsState.addAttribute("constraints", odsBuilder.getStringAttr(constraints)); - odsState.addAttribute("asm_flavor", AsmFlavorAttr::get(odsBuilder.getContext(), asm_flavor)); - + odsState.addAttribute( + "asm_flavor", AsmFlavorAttr::get(odsBuilder.getContext(), asm_flavor)); + if (side_effects) odsState.addAttribute("side_effects", odsBuilder.getUnitAttr()); - - odsState.addAttribute("operand_attrs", odsBuilder.getArrayAttr(operand_attrs)); + + odsState.addAttribute("operand_attrs", + odsBuilder.getArrayAttr(operand_attrs)); } ParseResult cir::InlineAsmOp::parse(OpAsmParser &parser, diff --git a/clang/lib/CIR/Dialect/IR/CIRMemorySlot.cpp b/clang/lib/CIR/Dialect/IR/CIRMemorySlot.cpp index dd3c5d1ba0c5..7545a82bc18e 100644 --- a/clang/lib/CIR/Dialect/IR/CIRMemorySlot.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRMemorySlot.cpp @@ -43,8 +43,8 @@ llvm::SmallVector cir::AllocaOp::getPromotableSlots() { Value cir::AllocaOp::getDefaultValue(const MemorySlot &slot, OpBuilder &builder) { - return builder.create(getLoc(), slot.elemType, - cir::UndefAttr::get(slot.elemType)); + return cir::ConstantOp::create(builder, getLoc(), slot.elemType, + cir::UndefAttr::get(slot.elemType)); } void cir::AllocaOp::handleBlockArgument(const MemorySlot &slot, @@ -141,7 +141,7 @@ bool cir::CopyOp::storesTo(const MemorySlot &slot) { Value cir::CopyOp::getStored(const MemorySlot &slot, OpBuilder &builder, Value reachingDef, const DataLayout &dataLayout) { - return builder.create(getLoc(), slot.elemType, getSrc()); + return cir::LoadOp::create(builder, getLoc(), slot.elemType, getSrc()); } DeletionKind cir::CopyOp::removeBlockingUses( @@ -149,10 +149,10 @@ DeletionKind cir::CopyOp::removeBlockingUses( OpBuilder &builder, Value reachingDefinition, const DataLayout &dataLayout) { if (loadsFrom(slot)) - builder.create(getLoc(), reachingDefinition, getDst(), - /*is_volatile=*/false, - /*is_nontemporal=*/false, mlir::IntegerAttr{}, - cir::MemOrderAttr(), cir::TBAAAttr{}); + cir::StoreOp::create(builder, getLoc(), reachingDefinition, getDst(), + /*is_volatile=*/false, + /*is_nontemporal=*/false, mlir::IntegerAttr{}, + cir::MemOrderAttr(), cir::TBAAAttr{}); return DeletionKind::Delete; } diff --git a/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp b/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp index cf5912687d20..f1a3200c3dd4 100644 --- a/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp +++ b/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp @@ -160,8 +160,8 @@ struct SimplifyPtrStrideOp : public OpRewritePattern { return mlir::failure(); base = getElemOp.getBase(); - index = rewriter.create(op->getLoc(), cir::BinOpKind::Add, - elemIndex, index); + index = cir::BinOp::create(rewriter, op->getLoc(), cir::BinOpKind::Add, + elemIndex, index); } else { return mlir::failure(); @@ -202,7 +202,7 @@ struct SimplifyCastOp : public OpRewritePattern { auto intType = cast(dataLayout.getIntType(context)); auto zeroAttr = rewriter.getAttr( intType, llvm::APInt(intType.getWidth(), 0)); - auto index = rewriter.create(op->getLoc(), zeroAttr); + auto index = cir::ConstantOp::create(rewriter, op->getLoc(), zeroAttr); rewriter.replaceOpWithNewOp(op, op.getType(), op.getOperand(), index); diff --git a/clang/lib/CIR/Dialect/Transforms/CallConvLowering.cpp b/clang/lib/CIR/Dialect/Transforms/CallConvLowering.cpp index 1a9d817abd05..e5358ce5e14e 100644 --- a/clang/lib/CIR/Dialect/Transforms/CallConvLowering.cpp +++ b/clang/lib/CIR/Dialect/Transforms/CallConvLowering.cpp @@ -76,7 +76,7 @@ struct CallConvLowering { void bitcast(mlir::Value src, mlir::Type newTy) { if (src.getType() != newTy) { auto cast = - rewriter.create(src.getLoc(), newTy, CastKind::bitcast, src); + CastOp::create(rewriter, src.getLoc(), newTy, CastKind::bitcast, src); rewriter.replaceAllUsesExcept(src, cast, cast); } } diff --git a/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp b/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp index d0c42aafdbdc..5bf4cdf5e07e 100644 --- a/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp +++ b/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp @@ -98,8 +98,8 @@ struct CIRIfFlattening : public OpRewritePattern { } rewriter.setInsertionPointToEnd(currentBlock); - rewriter.create(loc, ifOp.getCondition(), thenBeforeBody, - elseBeforeBody); + cir::BrCondOp::create(rewriter, loc, ifOp.getCondition(), thenBeforeBody, + elseBeforeBody); if (!emptyElse) { rewriter.setInsertionPointToEnd(elseAfterBody); @@ -149,10 +149,10 @@ class CIRScopeOpFlattening : public mlir::OpRewritePattern { // Save stack and then branch into the body of the region. rewriter.setInsertionPointToEnd(currentBlock); // TODO(CIR): stackSaveOp - // auto stackSaveOp = rewriter.create( + // auto stackSaveOp = mlir::LLVM::StackSaveOp::create(rewriter, // loc, mlir::LLVM::LLVMPointerType::get( // mlir::IntegerType::get(scopeOp.getContext(), 8))); - rewriter.create(loc, mlir::ValueRange(), beforeBody); + cir::BrOp::create(rewriter, loc, mlir::ValueRange(), beforeBody); // Replace the scopeop return with a branch that jumps out of the body. // Stack restore before leaving the body region. @@ -212,8 +212,8 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { cir::CatchParamKind::Begin)); rewriter.setInsertionPoint(yieldOp); - rewriter.create( - catchLoc, mlir::Type{}, nullptr, + cir::CatchParamOp::create( + rewriter, catchLoc, mlir::Type{}, nullptr, cir::CatchParamKindAttr::get(rewriter.getContext(), cir::CatchParamKind::End)); @@ -267,8 +267,8 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { cir::CatchParamKind::Begin)); rewriter.setInsertionPoint(yieldOp); - rewriter.create( - catchLoc, mlir::Type{}, nullptr, + cir::CatchParamOp::create( + rewriter, catchLoc, mlir::Type{}, nullptr, cir::CatchParamKindAttr::get(rewriter.getContext(), cir::CatchParamKind::End)); @@ -302,8 +302,8 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { mlir::Type typeIdType) const { rewriter.setInsertionPointToEnd(landingPadBlock); mlir::ArrayAttr symlist = collectTypeSymbols(tryOp); - auto inflightEh = rewriter.create( - tryOp.getLoc(), exceptionPtrType, typeIdType, + auto inflightEh = cir::EhInflightOp::create( + rewriter, tryOp.getLoc(), exceptionPtrType, typeIdType, tryOp.getCleanup() ? mlir::UnitAttr::get(tryOp.getContext()) : nullptr, symlist); auto selector = inflightEh.getTypeId(); @@ -328,8 +328,8 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { "expected two arguments in place"); dispatcherInitOps.push_back(selector); } - rewriter.create(tryOp.getLoc(), catchDispatcher, - dispatcherInitOps); + cir::BrOp::create(rewriter, tryOp.getLoc(), catchDispatcher, + dispatcherInitOps); return; } @@ -379,13 +379,13 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { if (auto typeIdGlobal = dyn_cast(catchAttr)) { auto *previousDispatcher = dispatcher; auto typeId = - rewriter.create(loc, typeIdGlobal.getSymbol()); + cir::EhTypeIdOp::create(rewriter, loc, typeIdGlobal.getSymbol()); auto ehPtr = previousDispatcher->getArgument(0); auto ehSel = previousDispatcher->getArgument(1); - auto match = rewriter.create( - loc, cir::BoolType::get(rewriter.getContext()), cir::CmpOpKind::eq, - ehSel, typeId); + auto match = cir::CmpOp::create(rewriter, loc, + cir::BoolType::get(rewriter.getContext()), + cir::CmpOpKind::eq, ehSel, typeId); mlir::Block *typeCatchBlock = buildTypeCase(rewriter, catchRegion, afterTry, ehPtr.getType()); @@ -401,8 +401,9 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { nextDispatchOps.push_back(ehSel); } - rewriter.create(loc, match, typeCatchBlock, nextDispatcher, - mlir::ValueRange{ehPtr}, nextDispatchOps); + cir::BrCondOp::create(rewriter, loc, match, typeCatchBlock, + nextDispatcher, mlir::ValueRange{ehPtr}, + nextDispatchOps); rewriter.setInsertionPointToEnd(nextDispatcher); } else if (auto catchAll = dyn_cast(catchAttr)) { // In case the catch(...) is all we got, `dispatcher` shall be @@ -480,7 +481,7 @@ class CIRTryOpFlattening : public mlir::OpRewritePattern { // Branch into the body of the region. rewriter.setInsertionPointToEnd(beforeTryScopeBlock); - rewriter.create(loc, mlir::ValueRange(), beforeBody); + cir::BrOp::create(rewriter, loc, mlir::ValueRange(), beforeBody); return afterTry; } @@ -582,7 +583,7 @@ class CIRLoopOpInterfaceFlattening // Setup loop entry branch. rewriter.setInsertionPointToEnd(entry); - rewriter.create(op.getLoc(), &op.getEntry().front()); + cir::BrOp::create(rewriter, op.getLoc(), &op.getEntry().front()); // Branch from condition region to body or exit. auto conditionOp = cast(cond->getTerminator()); @@ -658,26 +659,27 @@ class CIRSwitchOpFlattening : public mlir::OpRewritePattern { auto sIntType = cir::IntType::get(op.getContext(), 32, true); auto uIntType = cir::IntType::get(op.getContext(), 32, false); - auto rangeLength = rewriter.create( - op.getLoc(), cir::IntAttr::get(sIntType, upperBound - lowerBound)); + auto rangeLength = cir::ConstantOp::create( + rewriter, op.getLoc(), + cir::IntAttr::get(sIntType, upperBound - lowerBound)); - auto lowerBoundValue = rewriter.create( - op.getLoc(), cir::IntAttr::get(sIntType, lowerBound)); + auto lowerBoundValue = cir::ConstantOp::create( + rewriter, op.getLoc(), cir::IntAttr::get(sIntType, lowerBound)); auto diffValue = - rewriter.create(op.getLoc(), sIntType, cir::BinOpKind::Sub, - op.getCondition(), lowerBoundValue); + cir::BinOp::create(rewriter, op.getLoc(), sIntType, cir::BinOpKind::Sub, + op.getCondition(), lowerBoundValue); // Use unsigned comparison to check if the condition is in the range. - auto uDiffValue = rewriter.create( - op.getLoc(), uIntType, CastKind::integral, diffValue); - auto uRangeLength = rewriter.create( - op.getLoc(), uIntType, CastKind::integral, rangeLength); - - auto cmpResult = rewriter.create( - op.getLoc(), cir::BoolType::get(op.getContext()), cir::CmpOpKind::le, - uDiffValue, uRangeLength); - rewriter.create(op.getLoc(), cmpResult, rangeDestination, - defaultDestination); + auto uDiffValue = cir::CastOp::create(rewriter, op.getLoc(), uIntType, + CastKind::integral, diffValue); + auto uRangeLength = cir::CastOp::create(rewriter, op.getLoc(), uIntType, + CastKind::integral, rangeLength); + + auto cmpResult = cir::CmpOp::create( + rewriter, op.getLoc(), cir::BoolType::get(op.getContext()), + cir::CmpOpKind::le, uDiffValue, uRangeLength); + cir::BrCondOp::create(rewriter, op.getLoc(), cmpResult, rangeDestination, + defaultDestination); return resBlock; } @@ -724,7 +726,7 @@ class CIRSwitchOpFlattening : public mlir::OpRewritePattern { rewriteYieldOp(rewriter, switchYield, exitBlock); rewriter.setInsertionPointToEnd(originalBlock); - rewriter.create(op.getLoc(), swopBlock); + cir::BrOp::create(rewriter, op.getLoc(), swopBlock); } // Allocate required data structures (disconsider default case in @@ -793,8 +795,8 @@ class CIRSwitchOpFlattening : public mlir::OpRewritePattern { mlir::Block *newBlock = rewriter.splitBlock(oldBlock, nextOp->getIterator()); rewriter.setInsertionPointToEnd(oldBlock); - rewriter.create(nextOp->getLoc(), mlir::ValueRange(), - newBlock); + cir::BrOp::create(rewriter, nextOp->getLoc(), mlir::ValueRange(), + newBlock); rewriteYieldOp(rewriter, yieldOp, newBlock); } } @@ -808,7 +810,7 @@ class CIRSwitchOpFlattening : public mlir::OpRewritePattern { // Create a branch to the entry of the inlined region. rewriter.setInsertionPointToEnd(oldBlock); - rewriter.create(caseOp.getLoc(), &entryBlock); + cir::BrOp::create(rewriter, caseOp.getLoc(), &entryBlock); } // Remove all cases since we've inlined the regions. @@ -891,7 +893,7 @@ class CIRTernaryOpFlattening : public mlir::OpRewritePattern { rewriter.inlineRegionBefore(falseRegion, remainingOpsBlock); rewriter.setInsertionPointToEnd(condBlock); - rewriter.create(loc, op.getCond(), trueBlock, falseBlock); + cir::BrCondOp::create(rewriter, loc, op.getCond(), trueBlock, falseBlock); if (auto rt = op.getResultTypes(); rt.size()) { auto args = remainingOpsBlock->addArguments(rt, op.getLoc()); diff --git a/clang/lib/CIR/Dialect/Transforms/GotoSolver.cpp b/clang/lib/CIR/Dialect/Transforms/GotoSolver.cpp index 0389d8f5840e..637de9fa642b 100644 --- a/clang/lib/CIR/Dialect/Transforms/GotoSolver.cpp +++ b/clang/lib/CIR/Dialect/Transforms/GotoSolver.cpp @@ -52,7 +52,7 @@ static void process(cir::FuncOp func) { mlir::OpBuilder::InsertionGuard guard(rewriter); rewriter.setInsertionPoint(goTo); Block *dest = labels[goTo.getLabel()]; - rewriter.create(goTo.getLoc(), dest); + cir::BrOp::create(rewriter, goTo.getLoc(), dest); goTo.erase(); } } diff --git a/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp b/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp index a4de5f2af3ed..7bac5a655fd8 100644 --- a/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp +++ b/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp @@ -142,7 +142,7 @@ static void processConstAlloca(cir::AllocaOp alloca) { // operation. mlir::OpBuilder builder(alloca); auto invariantGroupOp = - builder.create(alloca.getLoc(), alloca); + cir::InvariantGroupOp::create(builder, alloca.getLoc(), alloca); // And replace all uses of the original alloca-ed pointer with the marked // pointer (which carries invariant group information). diff --git a/clang/lib/CIR/Dialect/Transforms/IdiomRecognizer.cpp b/clang/lib/CIR/Dialect/Transforms/IdiomRecognizer.cpp index 5b4a7ee20bca..291fbeed6686 100644 --- a/clang/lib/CIR/Dialect/Transforms/IdiomRecognizer.cpp +++ b/clang/lib/CIR/Dialect/Transforms/IdiomRecognizer.cpp @@ -42,9 +42,8 @@ template class StdRecognizer { template static TargetOp buildCall(CIRBaseBuilderTy &builder, CallOp call, std::index_sequence) { - return builder.create(call.getLoc(), call.getResult().getType(), - call.getCalleeAttr(), - call.getOperand(Indices)...); + return TargetOp::create(builder, call.getLoc(), call.getResult().getType(), + call.getCalleeAttr(), call.getOperand(Indices)...); } public: @@ -170,15 +169,15 @@ bool IdiomRecognizerPass::raiseIteratorBeginEnd(CallOp call) { if (callExprAttr.isIteratorBeginCall()) { if (opts.emitRemarkFoundCalls()) emitRemark(call.getLoc()) << "found call to begin() iterator"; - iterOp = builder.create( - call.getLoc(), call.getResult().getType(), call.getCalleeAttr(), - call.getOperand(0)); + iterOp = cir::IterBeginOp::create(builder, call.getLoc(), + call.getResult().getType(), + call.getCalleeAttr(), call.getOperand(0)); } else if (callExprAttr.isIteratorEndCall()) { if (opts.emitRemarkFoundCalls()) emitRemark(call.getLoc()) << "found call to end() iterator"; - iterOp = builder.create( - call.getLoc(), call.getResult().getType(), call.getCalleeAttr(), - call.getOperand(0)); + iterOp = cir::IterEndOp::create(builder, call.getLoc(), + call.getResult().getType(), + call.getCalleeAttr(), call.getOperand(0)); } else { return false; } diff --git a/clang/lib/CIR/Dialect/Transforms/LibOpt.cpp b/clang/lib/CIR/Dialect/Transforms/LibOpt.cpp index 29c8d58022e5..692d988a5706 100644 --- a/clang/lib/CIR/Dialect/Transforms/LibOpt.cpp +++ b/clang/lib/CIR/Dialect/Transforms/LibOpt.cpp @@ -131,7 +131,8 @@ void LibOptPass::xformStdFindIntoMemchr(StdFindOp findOp) { auto first = findOp.getOperand(0); auto last = findOp.getOperand(1); auto value = findOp->getOperand(2); - if (!mlir::isa(first.getType()) || !mlir::isa(last.getType())) + if (!mlir::isa(first.getType()) || + !mlir::isa(last.getType())) return; // Transformation: @@ -163,7 +164,7 @@ void LibOptPass::xformStdFindIntoMemchr(StdFindOp findOp) { // FIXME: get datalayout based "int" instead of fixed size 4. auto loadPattern = - builder.create(value.getLoc(), underlyingDataTy, value); + LoadOp::create(builder, value.getLoc(), underlyingDataTy, value); auto memchrOp1 = builder.createIntCast( loadPattern, IntType::get(builder.getContext(), 32, true)); @@ -177,22 +178,22 @@ void LibOptPass::xformStdFindIntoMemchr(StdFindOp findOp) { // Both operands have the same type, use iterBegin. // Look at this pointer to retrieve container information. - auto thisPtr = - mlir::cast(iterBegin.getOperand().getType()).getPointee(); + auto thisPtr = mlir::cast(iterBegin.getOperand().getType()) + .getPointee(); auto containerTy = mlir::dyn_cast(thisPtr); unsigned staticSize = 0; if (containerTy && isSequentialContainer(containerTy) && containerHasStaticSize(containerTy, staticSize)) { - return builder.create( - findOp.getLoc(), memchrOp0, memchrOp1, - builder.create( - findOp.getLoc(), cir::IntAttr::get(uInt64Ty, staticSize))); + return MemChrOp::create( + builder, findOp.getLoc(), memchrOp0, memchrOp1, + ConstantOp::create(builder, findOp.getLoc(), + cir::IntAttr::get(uInt64Ty, staticSize))); } } - return builder.create( - findOp.getLoc(), memchrOp0, memchrOp1, - builder.create(findOp.getLoc(), uInt64Ty, last, first)); + return MemChrOp::create( + builder, findOp.getLoc(), memchrOp0, memchrOp1, + PtrDiffOp::create(builder, findOp.getLoc(), uInt64Ty, last, first)); }(); auto MemChrResult = @@ -203,17 +204,17 @@ void LibOptPass::xformStdFindIntoMemchr(StdFindOp findOp) { // else // return last; auto NullPtr = builder.getNullPtr(first.getType(), findOp.getLoc()); - auto CmpResult = builder.create( - findOp.getLoc(), BoolType::get(builder.getContext()), CmpOpKind::eq, - NullPtr.getRes(), MemChrResult); + auto CmpResult = CmpOp::create(builder, findOp.getLoc(), + BoolType::get(builder.getContext()), + CmpOpKind::eq, NullPtr.getRes(), MemChrResult); - auto result = builder.create( - findOp.getLoc(), CmpResult.getResult(), + auto result = TernaryOp::create( + builder, findOp.getLoc(), CmpResult.getResult(), [&](mlir::OpBuilder &ob, mlir::Location Loc) { - ob.create(Loc, last); + YieldOp::create(ob, Loc, last); }, [&](mlir::OpBuilder &ob, mlir::Location Loc) { - ob.create(Loc, MemChrResult); + YieldOp::create(ob, Loc, MemChrResult); }); findOp.replaceAllUsesWith(result); diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp index d582849e033f..a2a04dc2a47d 100644 --- a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp +++ b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp @@ -210,7 +210,7 @@ GlobalOp LoweringPreparePass::buildRuntimeVariable( GlobalOp g = dyn_cast_or_null(SymbolTable::lookupNearestSymbolFrom( theModule, StringAttr::get(theModule->getContext(), name))); if (!g) { - g = builder.create(loc, name, type); + g = cir::GlobalOp::create(builder, loc, name, type); g.setLinkageAttr( cir::GlobalLinkageKindAttr::get(builder.getContext(), linkage)); mlir::SymbolTable::setSymbolVisibility( @@ -225,7 +225,7 @@ FuncOp LoweringPreparePass::buildRuntimeFunction( FuncOp f = dyn_cast_or_null(SymbolTable::lookupNearestSymbolFrom( theModule, StringAttr::get(theModule->getContext(), name))); if (!f) { - f = builder.create(loc, name, type); + f = cir::FuncOp::create(builder, loc, name, type); f.setLinkageAttr( cir::GlobalLinkageKindAttr::get(builder.getContext(), linkage)); mlir::SymbolTable::setSymbolVisibility( @@ -306,15 +306,15 @@ FuncOp LoweringPreparePass::buildCXXGlobalVarDeclInitFunc(GlobalOp op) { mlir::Value args[3]; auto dtorPtrTy = cir::PointerType::get(dtorFunc.getFunctionType()); // dtorPtrTy - args[0] = builder.create(dtorCall.getLoc(), dtorPtrTy, - dtorFunc.getSymName()); - args[0] = builder.create(dtorCall.getLoc(), voidFnPtrTy, - cir::CastKind::bitcast, args[0]); - args[1] = builder.create(dtorCall.getLoc(), voidPtrTy, - cir::CastKind::bitcast, - dtorCall.getArgOperand(0)); - args[2] = builder.create(Handle.getLoc(), HandlePtrTy, - Handle.getSymName()); + args[0] = cir::GetGlobalOp::create(builder, dtorCall.getLoc(), dtorPtrTy, + dtorFunc.getSymName()); + args[0] = cir::CastOp::create(builder, dtorCall.getLoc(), voidFnPtrTy, + cir::CastKind::bitcast, args[0]); + args[1] = + cir::CastOp::create(builder, dtorCall.getLoc(), voidPtrTy, + cir::CastKind::bitcast, dtorCall.getArgOperand(0)); + args[2] = cir::GetGlobalOp::create(builder, Handle.getLoc(), HandlePtrTy, + Handle.getSymName()); builder.createCallOp(dtorCall.getLoc(), fnAtExit, args); dtorCall->erase(); entryBB->getOperations().splice(entryBB->end(), dtorBlock.getOperations(), @@ -335,7 +335,7 @@ FuncOp LoweringPreparePass::buildCXXGlobalVarDeclInitFunc(GlobalOp op) { } assert(isa(*yieldOp)); - builder.create(yieldOp->getLoc()); + ReturnOp::create(builder, yieldOp->getLoc()); return f; } @@ -352,9 +352,8 @@ static void canonicalizeIntrinsicThreeWayCmp(CIRBaseBuilderTy &builder, auto canonicalizedCmpInfo = cir::CmpThreeWayInfoAttr::get(builder.getContext(), -1, 0, 1); mlir::Value result = - builder - .create(loc, op.getType(), op.getLhs(), - op.getRhs(), canonicalizedCmpInfo) + cir::CmpThreeWayOp::create(builder, loc, op.getType(), op.getLhs(), + op.getRhs(), canonicalizedCmpInfo) .getResult(); auto compareAndYield = [&](mlir::Value input, int64_t test, @@ -665,18 +664,17 @@ static mlir::Value lowerComplexMul(LoweringPreparePass &pass, auto resultImagIsNaN = builder.createIsNaN(loc, resultImag); auto resultRealAndImagAreNaN = builder.createLogicalAnd(loc, resultRealIsNaN, resultImagIsNaN); - return builder - .create( - loc, resultRealAndImagAreNaN, - [&](mlir::OpBuilder &, mlir::Location) { - auto libCallResult = buildComplexBinOpLibCall( - pass, builder, &getComplexMulLibCallName, loc, ty, lhsReal, - lhsImag, rhsReal, rhsImag); - builder.createYield(loc, libCallResult); - }, - [&](mlir::OpBuilder &, mlir::Location) { - builder.createYield(loc, algebraicResult); - }) + return cir::TernaryOp::create( + builder, loc, resultRealAndImagAreNaN, + [&](mlir::OpBuilder &, mlir::Location) { + auto libCallResult = buildComplexBinOpLibCall( + pass, builder, &getComplexMulLibCallName, loc, ty, lhsReal, + lhsImag, rhsReal, rhsImag); + builder.createYield(loc, libCallResult); + }, + [&](mlir::OpBuilder &, mlir::Location) { + builder.createYield(loc, algebraicResult); + }) .getResult(); } @@ -773,11 +771,11 @@ buildRangeReductionComplexDiv(CIRBaseBuilderTy &builder, mlir::Location loc, builder.createYield(loc, result); }; - auto cFabs = builder.create(loc, c); - auto dFabs = builder.create(loc, d); + auto cFabs = cir::FAbsOp::create(builder, loc, c); + auto dFabs = cir::FAbsOp::create(builder, loc, d); auto cmpResult = builder.createCompare(loc, cir::CmpOpKind::ge, cFabs, dFabs); - auto ternary = builder.create( - loc, cmpResult, trueBranchBuilder, falseBranchBuilder); + auto ternary = cir::TernaryOp::create(builder, loc, cmpResult, + trueBranchBuilder, falseBranchBuilder); return ternary.getResult(); } @@ -853,8 +851,8 @@ void LoweringPreparePass::lowerThreeWayCmpOp(CmpThreeWayOp op) { auto cmpInfo = op.getInfo(); auto buildCmpRes = [&](int64_t value) -> mlir::Value { - return builder.create( - loc, cir::IntAttr::get(op.getType(), value)); + return cir::ConstantOp::create(builder, loc, + cir::IntAttr::get(op.getType(), value)); }; auto ltRes = buildCmpRes(cmpInfo.getLt()); auto eqRes = buildCmpRes(cmpInfo.getEq()); @@ -862,7 +860,7 @@ void LoweringPreparePass::lowerThreeWayCmpOp(CmpThreeWayOp op) { auto buildCmp = [&](CmpOpKind kind) -> mlir::Value { auto ty = BoolType::get(&getContext()); - return builder.create(loc, ty, kind, op.getLhs(), op.getRhs()); + return cir::CmpOp::create(builder, loc, ty, kind, op.getLhs(), op.getRhs()); }; auto buildSelect = [&](mlir::Value condition, mlir::Value trueResult, mlir::Value falseResult) -> mlir::Value { @@ -988,7 +986,7 @@ void LoweringPreparePass::buildCXXGlobalInitFunc() { builder.createCallOp(f.getLoc(), f); } - builder.create(f.getLoc()); + ReturnOp::create(builder, f.getLoc()); } void LoweringPreparePass::buildCUDAModuleCtor() { @@ -1058,8 +1056,8 @@ void LoweringPreparePass::buildCUDAModuleCtor() { // OG gives an empty name to this global constant, // which is not allowed in CIR. std::string fatbinStrName = addUnderscoredPrefix(cudaPrefix, "_fatbin_str"); - GlobalOp fatbinStr = builder.create( - loc, fatbinStrName, fatbinType, /*isConstant=*/true, + GlobalOp fatbinStr = GlobalOp::create( + builder, loc, fatbinStrName, fatbinType, /*isConstant=*/true, /*linkage=*/cir::GlobalLinkageKind::PrivateLinkage); fatbinStr.setAlignment(8); fatbinStr.setInitialValueAttr(cir::ConstArrayAttr::get( @@ -1077,8 +1075,8 @@ void LoweringPreparePass::buildCUDAModuleCtor() { std::string fatbinWrapperName = addUnderscoredPrefix(cudaPrefix, "_fatbin_wrapper"); - GlobalOp fatbinWrapper = builder.create( - loc, fatbinWrapperName, fatbinWrapperType, /*isConstant=*/true, + GlobalOp fatbinWrapper = GlobalOp::create( + builder, loc, fatbinWrapperName, fatbinWrapperType, /*isConstant=*/true, /*linkage=*/cir::GlobalLinkageKind::InternalLinkage); fatbinWrapper.setPrivate(); fatbinWrapper.setSection(fatbinSectionName); @@ -1097,8 +1095,8 @@ void LoweringPreparePass::buildCUDAModuleCtor() { // GPU fat binary handle is also a global variable in OG. std::string gpubinHandleName = addUnderscoredPrefix(cudaPrefix, "_gpubin_handle"); - auto gpubinHandle = builder.create( - loc, gpubinHandleName, voidPtrPtrTy, + auto gpubinHandle = GlobalOp::create( + builder, loc, gpubinHandleName, voidPtrPtrTy, /*isConstant=*/false, /*linkage=*/GlobalLinkageKind::InternalLinkage); gpubinHandle.setInitialValueAttr(builder.getConstNullPtrAttr(voidPtrPtrTy)); gpubinHandle.setPrivate(); @@ -1165,13 +1163,13 @@ void LoweringPreparePass::buildCUDAModuleCtor() { globalBuilder, "atexit", loc, FuncType::get(PointerType::get(dtor->getFunctionType()), intTy)); - mlir::Value dtorFunc = builder.create( - loc, PointerType::get(dtor->getFunctionType()), + mlir::Value dtorFunc = GetGlobalOp::create( + builder, loc, PointerType::get(dtor->getFunctionType()), mlir::FlatSymbolRefAttr::get(dtor->getSymNameAttr())); builder.createCallOp(loc, atexit, dtorFunc); } - builder.create(loc); + cir::ReturnOp::create(builder, loc); } std::optional LoweringPreparePass::buildCUDARegisterGlobals() { @@ -1203,7 +1201,7 @@ std::optional LoweringPreparePass::buildCUDARegisterGlobals() { // TODO(cir): registration for global variables. - builder.create(loc); + ReturnOp::create(builder, loc); return regGlobalFunc; } @@ -1245,8 +1243,8 @@ void LoweringPreparePass::buildCUDARegisterGlobalFunctions( auto makeConstantString = [&](llvm::StringRef str) -> GlobalOp { auto strType = ArrayType::get(&getContext(), charTy, 1 + str.size()); - auto tmpString = globalBuilder.create( - loc, (".str" + str).str(), strType, /*isConstant=*/true, + auto tmpString = GlobalOp::create( + globalBuilder, loc, (".str" + str).str(), strType, /*isConstant=*/true, /*linkage=*/cir::GlobalLinkageKind::PrivateLinkage); // We must make the string zero-terminated. @@ -1263,14 +1261,14 @@ void LoweringPreparePass::buildCUDARegisterGlobalFunctions( mlir::Value deviceFunc = builder.createBitcast( builder.createGetGlobal(deviceFuncStr), voidPtrTy); mlir::Value hostFunc = builder.createBitcast( - builder.create( - loc, PointerType::get(deviceStub.getFunctionType()), + GetGlobalOp::create( + builder, loc, PointerType::get(deviceStub.getFunctionType()), mlir::FlatSymbolRefAttr::get(deviceStub.getSymNameAttr())), voidPtrTy); builder.createCallOp( loc, cudaRegisterFunction, {fatbinHandle, hostFunc, deviceFunc, deviceFunc, - builder.create(loc, IntAttr::get(intTy, -1)), cirNullPtr, + ConstantOp::create(builder, loc, IntAttr::get(intTy, -1)), cirNullPtr, cirNullPtr, cirNullPtr, cirNullPtr, cirNullPtr}); } } @@ -1315,7 +1313,7 @@ std::optional LoweringPreparePass::buildCUDAModuleDtor() { mlir::Value gpubinAddress = builder.createGetGlobal(gpubinGlobal); mlir::Value gpubin = builder.createLoad(loc, gpubinAddress); builder.createCallOp(loc, unregisterFunc, gpubin); - builder.create(loc); + ReturnOp::create(builder, loc); return dtor; } @@ -1343,13 +1341,13 @@ static void lowerArrayDtorCtorIntoLoop(CIRBaseBuilderTy &builder, auto ptrDiffTy = cir::IntType::get(builder.getContext(), 64, /*signed=*/false); uint64_t endOffset = isCtor ? arrayLen : arrayLen - 1; - mlir::Value endOffsetVal = builder.create( - loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, endOffset)); + mlir::Value endOffsetVal = cir::ConstantOp::create( + builder, loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, endOffset)); - auto begin = builder.create( - loc, eltTy, cir::CastKind::array_to_ptrdecay, arrayAddr); + auto begin = cir::CastOp::create(builder, loc, eltTy, + cir::CastKind::array_to_ptrdecay, arrayAddr); mlir::Value end = - builder.create(loc, eltTy, begin, endOffsetVal); + cir::PtrStrideOp::create(builder, loc, eltTy, begin, endOffsetVal); mlir::Value start = isCtor ? begin : end; mlir::Value stop = isCtor ? end : begin; @@ -1362,15 +1360,15 @@ static void lowerArrayDtorCtorIntoLoop(CIRBaseBuilderTy &builder, loc, /*condBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { - auto currentElement = b.create(loc, eltTy, tmpAddr); + auto currentElement = cir::LoadOp::create(b, loc, eltTy, tmpAddr); mlir::Type boolTy = cir::BoolType::get(b.getContext()); - auto cmp = builder.create(loc, boolTy, cir::CmpOpKind::ne, - currentElement, stop); + auto cmp = cir::CmpOp::create(builder, loc, boolTy, cir::CmpOpKind::ne, + currentElement, stop); builder.createCondition(cmp); }, /*bodyBuilder=*/ [&](mlir::OpBuilder &b, mlir::Location loc) { - auto currentElement = b.create(loc, eltTy, tmpAddr); + auto currentElement = cir::LoadOp::create(b, loc, eltTy, tmpAddr); CallOp ctorCall; op->walk([&](CallOp c) { ctorCall = c; }); @@ -1378,18 +1376,18 @@ static void lowerArrayDtorCtorIntoLoop(CIRBaseBuilderTy &builder, cir::ConstantOp stride; if (isCtor) - stride = builder.create( - loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, 1)); + stride = cir::ConstantOp::create(builder, loc, ptrDiffTy, + cir::IntAttr::get(ptrDiffTy, 1)); else - stride = builder.create( - loc, ptrDiffTy, cir::IntAttr::get(ptrDiffTy, -1)); + stride = cir::ConstantOp::create(builder, loc, ptrDiffTy, + cir::IntAttr::get(ptrDiffTy, -1)); ctorCall->moveBefore(stride); ctorCall->setOperand(0, currentElement); // Advance pointer and store them to temporary variable - auto nextElement = builder.create( - loc, eltTy, currentElement, stride); + auto nextElement = cir::PtrStrideOp::create(builder, loc, eltTy, + currentElement, stride); builder.createStore(loc, nextElement, tmpAddr); builder.createYield(loc); }); diff --git a/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp index 3e96792694d7..8f37f786552e 100644 --- a/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp +++ b/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp @@ -76,8 +76,8 @@ struct canonicalizeIVtoCmpLHS : public OpRewritePattern { void replaceWithNewCmpOp(CmpOp oldCmp, CmpOpKind newKind, Value lhs, Value rhs, PatternRewriter &rewriter) const { rewriter.setInsertionPointAfter(oldCmp.getOperation()); - auto newCmp = rewriter.create(oldCmp.getLoc(), oldCmp.getType(), - newKind, lhs, rhs); + auto newCmp = cir::CmpOp::create(rewriter, oldCmp.getLoc(), + oldCmp.getType(), newKind, lhs, rhs); oldCmp->replaceAllUsesWith(newCmp); oldCmp->erase(); } diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.cpp index 108ef5995701..b32f39315eb4 100644 --- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.cpp +++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.cpp @@ -44,8 +44,8 @@ mlir::Value emitRoundPointerUpToAlignment(cir::CIRBaseBuilderTy &builder, loc, builder.createPtrBitcast(ptr, builder.getUIntNTy(8)), builder.getUnsignedInt(loc, alignment - 1, /*width=*/32)); auto dataLayout = mlir::DataLayout::closest(roundUp.getDefiningOp()); - return builder.create( - loc, roundUp.getType(), roundUp, + return cir::PtrMaskOp::create( + builder, loc, roundUp.getType(), roundUp, builder.getSignedInt(loc, -(signed)alignment, dataLayout.getTypeSizeInBits(roundUp.getType()))); } diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp index 17ff1433bf4a..47cb5c1fd7ad 100644 --- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp +++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/ItaniumCXXABI.cpp @@ -277,12 +277,12 @@ mlir::Operation *ItaniumCXXABI::lowerGetRuntimeMember( auto byteTy = IntType::get(op.getContext(), 8, true); auto bytePtrTy = PointerType::get( byteTy, mlir::cast(op.getAddr().getType()).getAddrSpace()); - auto objectBytesPtr = builder.create(op.getLoc(), bytePtrTy, - CastKind::bitcast, op.getAddr()); - auto memberBytesPtr = builder.create( - op.getLoc(), bytePtrTy, objectBytesPtr, loweredMember); - return builder.create(op.getLoc(), op.getType(), CastKind::bitcast, - memberBytesPtr); + auto objectBytesPtr = CastOp::create(builder, op.getLoc(), bytePtrTy, + CastKind::bitcast, op.getAddr()); + auto memberBytesPtr = PtrStrideOp::create(builder, op.getLoc(), bytePtrTy, + objectBytesPtr, loweredMember); + return CastOp::create(builder, op.getLoc(), op.getType(), CastKind::bitcast, + memberBytesPtr); } void ItaniumCXXABI::lowerGetMethod( @@ -315,11 +315,11 @@ void ItaniumCXXABI::lowerGetMethod( mlir::Type calleePtrTy = op.getCallee().getType(); cir::IntType ptrdiffCIRTy = getPtrDiffCIRTy(LM); - mlir::Value ptrdiffOne = rewriter.create( - op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 1)); + mlir::Value ptrdiffOne = cir::ConstantOp::create( + rewriter, op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 1)); - mlir::Value adj = rewriter.create( - op.getLoc(), ptrdiffCIRTy, loweredMethod, 1); + mlir::Value adj = cir::ExtractMemberOp::create( + rewriter, op.getLoc(), ptrdiffCIRTy, loweredMethod, 1); if (UseARMMethodPtrABI) llvm_unreachable("ARM method ptr abi NYI"); @@ -327,23 +327,24 @@ void ItaniumCXXABI::lowerGetMethod( mlir::Type thisVoidPtrTy = cir::PointerType::get(cir::VoidType::get(rewriter.getContext()), op.getObject().getType().getAddrSpace()); - mlir::Value thisVoidPtr = rewriter.create( - op.getLoc(), thisVoidPtrTy, cir::CastKind::bitcast, loweredObjectPtr); - adjustedThis = rewriter.create(op.getLoc(), thisVoidPtrTy, - thisVoidPtr, adj); + mlir::Value thisVoidPtr = + cir::CastOp::create(rewriter, op.getLoc(), thisVoidPtrTy, + cir::CastKind::bitcast, loweredObjectPtr); + adjustedThis = cir::PtrStrideOp::create(rewriter, op.getLoc(), thisVoidPtrTy, + thisVoidPtr, adj); // Load the "ptr" field of the member function pointer and determine if it // points to a virtual function. - mlir::Value methodPtrField = rewriter.create( - op.getLoc(), ptrdiffCIRTy, loweredMethod, 0); - mlir::Value virtualBit = rewriter.create( - op.getLoc(), cir::BinOpKind::And, methodPtrField, ptrdiffOne); + mlir::Value methodPtrField = cir::ExtractMemberOp::create( + rewriter, op.getLoc(), ptrdiffCIRTy, loweredMethod, 0); + mlir::Value virtualBit = cir::BinOp::create( + rewriter, op.getLoc(), cir::BinOpKind::And, methodPtrField, ptrdiffOne); mlir::Value isVirtual; if (UseARMMethodPtrABI) llvm_unreachable("ARM method ptr abi NYI"); else - isVirtual = rewriter.create(op.getLoc(), cir::CmpOpKind::eq, - virtualBit, ptrdiffOne); + isVirtual = cir::CmpOp::create(rewriter, op.getLoc(), cir::CmpOpKind::eq, + virtualBit, ptrdiffOne); assert(!MissingFeatures::emitCFICheck()); assert(!MissingFeatures::emitVFEInfo()); @@ -365,8 +366,8 @@ void ItaniumCXXABI::lowerGetMethod( mlir::Block *virtualBlock = rewriter.createBlock(continueBlock); mlir::Block *nonVirtualBlock = rewriter.createBlock(continueBlock); rewriter.setInsertionPointToEnd(currBlock); - rewriter.create(op.getLoc(), isVirtual, virtualBlock, - nonVirtualBlock); + cir::BrCondOp::create(rewriter, op.getLoc(), isVirtual, virtualBlock, + nonVirtualBlock); auto buildVirtualBranch = [&] { mlir::OpBuilder::InsertionGuard guard(rewriter); @@ -378,10 +379,12 @@ void ItaniumCXXABI::lowerGetMethod( cir::IntType::get(rewriter.getContext(), 8, true)); auto vtablePtrPtrTy = cir::PointerType::get( vtablePtrTy, op.getObject().getType().getAddrSpace()); - auto vtablePtrPtr = rewriter.create( - op.getLoc(), vtablePtrPtrTy, cir::CastKind::bitcast, loweredObjectPtr); - mlir::Value vtablePtr = rewriter.create( - op.getLoc(), vtablePtrPtr, /*isDeref=*/false, /*isVolatile=*/false, + auto vtablePtrPtr = + cir::CastOp::create(rewriter, op.getLoc(), vtablePtrPtrTy, + cir::CastKind::bitcast, loweredObjectPtr); + mlir::Value vtablePtr = cir::LoadOp::create( + rewriter, op.getLoc(), vtablePtrPtr, /*isDeref=*/false, + /*isVolatile=*/false, /*isNontemporal=*/false, /*alignment=*/mlir::IntegerAttr(), /*mem_order=*/cir::MemOrderAttr(), /*tbaa=*/mlir::ArrayAttr()); @@ -389,8 +392,8 @@ void ItaniumCXXABI::lowerGetMethod( // Get the vtable offset. mlir::Value vtableOffset = methodPtrField; if (!UseARMMethodPtrABI) - vtableOffset = rewriter.create( - op.getLoc(), cir::BinOpKind::Sub, vtableOffset, ptrdiffOne); + vtableOffset = cir::BinOp::create( + rewriter, op.getLoc(), cir::BinOpKind::Sub, vtableOffset, ptrdiffOne); if (Use32BitVTableOffsetABI) llvm_unreachable("NYI"); @@ -409,37 +412,38 @@ void ItaniumCXXABI::lowerGetMethod( if (VTComponentLayout == VTableComponentLayout::Relative) llvm_unreachable("NYI"); else { - mlir::Value vfpAddr = rewriter.create( - op.getLoc(), vtablePtrTy, vtablePtr, vtableOffset); + mlir::Value vfpAddr = cir::PtrStrideOp::create( + rewriter, op.getLoc(), vtablePtrTy, vtablePtr, vtableOffset); auto vfpPtrTy = cir::PointerType::get(calleePtrTy); - mlir::Value vfpPtr = rewriter.create( - op.getLoc(), vfpPtrTy, cir::CastKind::bitcast, vfpAddr); - funcPtr = rewriter.create( - op.getLoc(), vfpPtr, /*isDeref=*/false, /*isVolatile=*/false, - /*isNontemporal=*/false, - /*alignment=*/mlir::IntegerAttr(), - /*mem_order=*/cir::MemOrderAttr(), - /*tbaa=*/mlir::ArrayAttr()); + mlir::Value vfpPtr = cir::CastOp::create( + rewriter, op.getLoc(), vfpPtrTy, cir::CastKind::bitcast, vfpAddr); + funcPtr = cir::LoadOp::create(rewriter, op.getLoc(), vfpPtr, + /*isDeref=*/false, /*isVolatile=*/false, + /*isNontemporal=*/false, + /*alignment=*/mlir::IntegerAttr(), + /*mem_order=*/cir::MemOrderAttr(), + /*tbaa=*/mlir::ArrayAttr()); } } if (shouldEmitCFICheck) llvm_unreachable("NYI"); - rewriter.create(op.getLoc(), continueBlock, funcPtr); + cir::BrOp::create(rewriter, op.getLoc(), continueBlock, funcPtr); }; auto buildNonVirtualBranch = [&] { mlir::OpBuilder::InsertionGuard guard(rewriter); rewriter.setInsertionPointToStart(nonVirtualBlock); - mlir::Value funcPtr = rewriter.create( - op.getLoc(), calleePtrTy, cir::CastKind::int_to_ptr, methodPtrField); + mlir::Value funcPtr = + cir::CastOp::create(rewriter, op.getLoc(), calleePtrTy, + cir::CastKind::int_to_ptr, methodPtrField); if (shouldEmitCFICheck) llvm_unreachable("NYI"); - rewriter.create(op.getLoc(), continueBlock, funcPtr); + cir::BrOp::create(rewriter, op.getLoc(), continueBlock, funcPtr); }; buildVirtualBranch(); @@ -457,19 +461,21 @@ static mlir::Value lowerDataMemberCast(mlir::Operation *op, if (offset == 0) return loweredSrc; - auto nullValue = builder.create( - op->getLoc(), mlir::IntegerAttr::get(loweredSrc.getType(), -1)); - auto isNull = builder.create(op->getLoc(), cir::CmpOpKind::eq, - loweredSrc, nullValue); + auto nullValue = cir::ConstantOp::create( + builder, op->getLoc(), mlir::IntegerAttr::get(loweredSrc.getType(), -1)); + auto isNull = cir::CmpOp::create(builder, op->getLoc(), cir::CmpOpKind::eq, + loweredSrc, nullValue); - auto offsetValue = builder.create( - op->getLoc(), mlir::IntegerAttr::get(loweredSrc.getType(), offset)); + auto offsetValue = cir::ConstantOp::create( + builder, op->getLoc(), + mlir::IntegerAttr::get(loweredSrc.getType(), offset)); auto binOpKind = isDerivedToBase ? cir::BinOpKind::Sub : cir::BinOpKind::Add; - auto adjustedPtr = builder.create( - op->getLoc(), loweredSrc.getType(), binOpKind, loweredSrc, offsetValue); + auto adjustedPtr = + cir::BinOp::create(builder, op->getLoc(), loweredSrc.getType(), binOpKind, + loweredSrc, offsetValue); - return builder.create(op->getLoc(), loweredSrc.getType(), - isNull, nullValue, adjustedPtr); + return cir::SelectOp::create(builder, op->getLoc(), loweredSrc.getType(), + isNull, nullValue, adjustedPtr); } static mlir::Value lowerMethodCast(mlir::Operation *op, mlir::Value loweredSrc, @@ -480,17 +486,17 @@ static mlir::Value lowerMethodCast(mlir::Operation *op, mlir::Value loweredSrc, return loweredSrc; cir::IntType ptrdiffCIRTy = getPtrDiffCIRTy(lowerMod); - auto adjField = builder.create( - op->getLoc(), ptrdiffCIRTy, loweredSrc, 1); + auto adjField = cir::ExtractMemberOp::create(builder, op->getLoc(), + ptrdiffCIRTy, loweredSrc, 1); - auto offsetValue = builder.create( - op->getLoc(), cir::IntAttr::get(ptrdiffCIRTy, offset)); + auto offsetValue = cir::ConstantOp::create( + builder, op->getLoc(), cir::IntAttr::get(ptrdiffCIRTy, offset)); auto binOpKind = isDerivedToBase ? cir::BinOpKind::Sub : cir::BinOpKind::Add; - auto adjustedAdjField = builder.create( - op->getLoc(), ptrdiffCIRTy, binOpKind, adjField, offsetValue); + auto adjustedAdjField = cir::BinOp::create( + builder, op->getLoc(), ptrdiffCIRTy, binOpKind, adjField, offsetValue); - return builder.create(op->getLoc(), loweredSrc, 1, - adjustedAdjField); + return cir::InsertMemberOp::create(builder, op->getLoc(), loweredSrc, 1, + adjustedAdjField); } mlir::Value ItaniumCXXABI::lowerBaseDataMember(cir::BaseDataMemberOp op, @@ -526,8 +532,8 @@ mlir::Value ItaniumCXXABI::lowerDataMemberCmp(cir::CmpOp op, mlir::Value loweredLhs, mlir::Value loweredRhs, mlir::OpBuilder &builder) const { - return builder.create(op.getLoc(), op.getKind(), loweredLhs, - loweredRhs); + return cir::CmpOp::create(builder, op.getLoc(), op.getKind(), loweredLhs, + loweredRhs); } mlir::Value ItaniumCXXABI::lowerMethodCmp(cir::CmpOp op, mlir::Value loweredLhs, @@ -537,24 +543,24 @@ mlir::Value ItaniumCXXABI::lowerMethodCmp(cir::CmpOp op, mlir::Value loweredLhs, op.getKind() == cir::CmpOpKind::ne); cir::IntType ptrdiffCIRTy = getPtrDiffCIRTy(LM); - mlir::Value ptrdiffZero = builder.create( - op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 0)); - - mlir::Value lhsPtrField = builder.create( - op.getLoc(), ptrdiffCIRTy, loweredLhs, 0); - mlir::Value rhsPtrField = builder.create( - op.getLoc(), ptrdiffCIRTy, loweredRhs, 0); - mlir::Value ptrCmp = builder.create(op.getLoc(), op.getKind(), - lhsPtrField, rhsPtrField); - mlir::Value ptrCmpToNull = builder.create( - op.getLoc(), op.getKind(), lhsPtrField, ptrdiffZero); - - mlir::Value lhsAdjField = builder.create( - op.getLoc(), ptrdiffCIRTy, loweredLhs, 1); - mlir::Value rhsAdjField = builder.create( - op.getLoc(), ptrdiffCIRTy, loweredRhs, 1); - mlir::Value adjCmp = builder.create(op.getLoc(), op.getKind(), - lhsAdjField, rhsAdjField); + mlir::Value ptrdiffZero = cir::ConstantOp::create( + builder, op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 0)); + + mlir::Value lhsPtrField = cir::ExtractMemberOp::create( + builder, op.getLoc(), ptrdiffCIRTy, loweredLhs, 0); + mlir::Value rhsPtrField = cir::ExtractMemberOp::create( + builder, op.getLoc(), ptrdiffCIRTy, loweredRhs, 0); + mlir::Value ptrCmp = cir::CmpOp::create(builder, op.getLoc(), op.getKind(), + lhsPtrField, rhsPtrField); + mlir::Value ptrCmpToNull = cir::CmpOp::create( + builder, op.getLoc(), op.getKind(), lhsPtrField, ptrdiffZero); + + mlir::Value lhsAdjField = cir::ExtractMemberOp::create( + builder, op.getLoc(), ptrdiffCIRTy, loweredLhs, 1); + mlir::Value rhsAdjField = cir::ExtractMemberOp::create( + builder, op.getLoc(), ptrdiffCIRTy, loweredRhs, 1); + mlir::Value adjCmp = cir::CmpOp::create(builder, op.getLoc(), op.getKind(), + lhsAdjField, rhsAdjField); // We use cir.select to represent "||" and "&&" operations below: // - cir.select if %a then %b else false => %a && %b @@ -565,10 +571,10 @@ mlir::Value ItaniumCXXABI::lowerMethodCmp(cir::CmpOp op, mlir::Value loweredLhs, mlir::Value trueValue = cirBuilder.getTrue(op.getLoc()); mlir::Value falseValue = cirBuilder.getFalse(op.getLoc()); auto create_and = [&](mlir::Value lhs, mlir::Value rhs) { - return builder.create(op.getLoc(), lhs, rhs, falseValue); + return cir::SelectOp::create(builder, op.getLoc(), lhs, rhs, falseValue); }; auto create_or = [&](mlir::Value lhs, mlir::Value rhs) { - return builder.create(op.getLoc(), lhs, trueValue, rhs); + return cir::SelectOp::create(builder, op.getLoc(), lhs, trueValue, rhs); }; mlir::Value result; @@ -587,8 +593,8 @@ mlir::Value ItaniumCXXABI::lowerDataMemberBitcast(cir::CastOp op, mlir::Type loweredDstTy, mlir::Value loweredSrc, mlir::OpBuilder &builder) const { - return builder.create(op.getLoc(), loweredDstTy, - cir::CastKind::bitcast, loweredSrc); + return cir::CastOp::create(builder, op.getLoc(), loweredDstTy, + cir::CastKind::bitcast, loweredSrc); } mlir::Value @@ -597,9 +603,9 @@ ItaniumCXXABI::lowerDataMemberToBoolCast(cir::CastOp op, mlir::Value loweredSrc, // Itanium C++ ABI 2.3: // A NULL pointer is represented as -1. auto nullAttr = cir::IntAttr::get(getPtrDiffCIRTy(LM), -1); - auto nullValue = builder.create(op.getLoc(), nullAttr); - return builder.create(op.getLoc(), cir::CmpOpKind::ne, loweredSrc, - nullValue); + auto nullValue = cir::ConstantOp::create(builder, op.getLoc(), nullAttr); + return cir::CmpOp::create(builder, op.getLoc(), cir::CmpOpKind::ne, + loweredSrc, nullValue); } mlir::Value ItaniumCXXABI::lowerMethodBitcast(cir::CastOp op, @@ -618,12 +624,12 @@ ItaniumCXXABI::lowerMethodToBoolCast(cir::CastOp op, mlir::Value loweredSrc, // represented with ptr set to a null pointer. The value of adj is // unspecified for null member function pointers. cir::IntType ptrdiffCIRTy = getPtrDiffCIRTy(LM); - mlir::Value ptrdiffZero = builder.create( - op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 0)); - mlir::Value ptrField = builder.create( - op.getLoc(), ptrdiffCIRTy, loweredSrc, 0); - return builder.create(op.getLoc(), cir::CmpOpKind::ne, ptrField, - ptrdiffZero); + mlir::Value ptrdiffZero = cir::ConstantOp::create( + builder, op.getLoc(), cir::IntAttr::get(ptrdiffCIRTy, 0)); + mlir::Value ptrField = cir::ExtractMemberOp::create( + builder, op.getLoc(), ptrdiffCIRTy, loweredSrc, 0); + return cir::CmpOp::create(builder, op.getLoc(), cir::CmpOpKind::ne, ptrField, + ptrdiffZero); } CIRCXXABI *CreateItaniumCXXABI(LowerModule &LM) { diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerFunction.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerFunction.cpp index 49f17df27491..dc9bf64ba3d6 100644 --- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerFunction.cpp +++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerFunction.cpp @@ -46,17 +46,17 @@ mlir::Value createCoercedBitcast(mlir::Value Src, mlir::Type DestTy, auto destPtrTy = cir::PointerType::get(DestTy); if (auto load = Src.getDefiningOp()) - return CGF.getRewriter().create(Src.getLoc(), destPtrTy, - CastKind::bitcast, load.getAddr()); + return CastOp::create(CGF.getRewriter(), Src.getLoc(), destPtrTy, + CastKind::bitcast, load.getAddr()); - return CGF.getRewriter().create(Src.getLoc(), destPtrTy, - CastKind::bitcast, Src); + return CastOp::create(CGF.getRewriter(), Src.getLoc(), destPtrTy, + CastKind::bitcast, Src); } // FIXME(cir): Create a custom rewriter class to abstract this away. mlir::Value createBitcast(mlir::Value Src, mlir::Type Ty, LowerFunction &LF) { - return LF.getRewriter().create(Src.getLoc(), Ty, CastKind::bitcast, - Src); + return CastOp::create(LF.getRewriter(), Src.getLoc(), Ty, CastKind::bitcast, + Src); } /// Given a record pointer that we are accessing some number of bytes out of it, @@ -97,7 +97,7 @@ mlir::Value enterRecordPointerForCoercedAccess(mlir::Value SrcPtr, // that may or may not be the first one. Thus, getMemberOp verification // may fail. auto cast = createBitcast(addr, ptrTy, CGF); - SrcPtr = rw.create(SrcPtr.getLoc(), cast); + SrcPtr = LoadOp::create(rw, SrcPtr.getLoc(), cast); } if (auto sty = mlir::dyn_cast(SrcPtr.getType())) @@ -123,10 +123,10 @@ static mlir::Value coerceIntOrPtrToIntOrPtr(mlir::Value val, mlir::Type typ, if (mlir::isa(val.getType())) { // If this is Pointer->Pointer avoid conversion to and from int. if (mlir::isa(typ)) - return bld.create(val.getLoc(), typ, CastKind::bitcast, val); + return CastOp::create(bld, val.getLoc(), typ, CastKind::bitcast, val); // Convert the pointer to an integer so we can play with its width. - val = bld.create(val.getLoc(), typ, CastKind::ptr_to_int, val); + val = CastOp::create(bld, val.getLoc(), typ, CastKind::ptr_to_int, val); } auto dstIntTy = typ; @@ -144,23 +144,24 @@ static mlir::Value coerceIntOrPtrToIntOrPtr(mlir::Value val, mlir::Type typ, auto loc = val.getLoc(); if (srcSize > dstSize) { auto intAttr = IntAttr::get(val.getType(), diff); - auto amount = bld.create(loc, intAttr); - val = bld.create(loc, val.getType(), val, amount, false); - val = bld.create(loc, dstIntTy, CastKind::integral, val); + auto amount = ConstantOp::create(bld, loc, intAttr); + val = ShiftOp::create(bld, loc, val.getType(), val, amount, false); + val = CastOp::create(bld, loc, dstIntTy, CastKind::integral, val); } else { - val = bld.create(loc, dstIntTy, CastKind::integral, val); + val = CastOp::create(bld, loc, dstIntTy, CastKind::integral, val); auto intAttr = IntAttr::get(val.getType(), diff); - auto amount = bld.create(loc, intAttr); - val = bld.create(loc, val.getType(), val, amount, true); + auto amount = ConstantOp::create(bld, loc, intAttr); + val = ShiftOp::create(bld, loc, val.getType(), val, amount, true); } } else { // Little-endian targets preserve the low bits. No shifts required. - val = bld.create(val.getLoc(), dstIntTy, CastKind::integral, val); + val = + CastOp::create(bld, val.getLoc(), dstIntTy, CastKind::integral, val); } } if (mlir::isa(typ)) - val = bld.create(val.getLoc(), typ, CastKind::int_to_ptr, val); + val = CastOp::create(bld, val.getLoc(), typ, CastKind::int_to_ptr, val); return val; } @@ -183,7 +184,7 @@ AllocaOp createTmpAlloca(LowerFunction &LF, mlir::Location loc, mlir::Type ty) { auto align = LF.LM.getDataLayout().getABITypeAlign(ty); auto alignAttr = rw.getI64IntegerAttr(align.value()); auto ptrTy = PointerType::get(ty); - return rw.create(loc, ptrTy, ty, "tmp", alignAttr); + return AllocaOp::create(rw, loc, ptrTy, ty, "tmp", alignAttr); } bool isVoidPtr(mlir::Value v) { @@ -207,8 +208,8 @@ MemCpyOp createMemCpy(LowerFunction &LF, mlir::Value dst, mlir::Value src, dst = createBitcast(dst, voidPtr, LF); auto i64Ty = IntType::get(ctxt, 64, false); - auto length = rw.create(src.getLoc(), IntAttr::get(i64Ty, len)); - return rw.create(src.getLoc(), dst, src, length); + auto length = ConstantOp::create(rw, src.getLoc(), IntAttr::get(i64Ty, len)); + return MemCpyOp::create(rw, src.getLoc(), dst, src, length); } cir::AllocaOp findAlloca(mlir::Operation *op) { @@ -285,11 +286,12 @@ void createCoercedStore(mlir::Value Src, mlir::Value Dst, bool DstIsVolatile, auto dstIntTy = IntType::get(ctxt, DstSize.getFixedValue() * 8, false); Src = coerceIntOrPtrToIntOrPtr(Src, dstIntTy, CGF); auto ptrTy = PointerType::get(dstIntTy); - auto addr = bld.create(Dst.getLoc(), ptrTy, CastKind::bitcast, Dst); - bld.create(Dst.getLoc(), Src, addr); + auto addr = + CastOp::create(bld, Dst.getLoc(), ptrTy, CastKind::bitcast, Dst); + StoreOp::create(bld, Dst.getLoc(), Src, addr); } else { auto tmp = createTmpAlloca(CGF, Src.getLoc(), SrcTy); - CGF.getRewriter().create(Src.getLoc(), Src, tmp); + StoreOp::create(CGF.getRewriter(), Src.getLoc(), Src, tmp); createMemCpy(CGF, Dst, tmp, DstSize.getFixedValue()); } } @@ -350,8 +352,8 @@ mlir::Value createCoercedValue(mlir::Value Src, mlir::Type Ty, if (mlir::Value addr = findAddr(Src)) { auto tmpAlloca = createTmpAlloca(CGF, addr.getLoc(), Ty); createMemCpy(CGF, tmpAlloca, addr, SrcSize.getFixedValue()); - return CGF.getRewriter().create(addr.getLoc(), - tmpAlloca.getResult()); + return LoadOp::create(CGF.getRewriter(), addr.getLoc(), + tmpAlloca.getResult()); } cir_cconv_unreachable("NYI"); @@ -374,13 +376,13 @@ mlir::Value createCoercedNonFundamental(mlir::Value src, mlir::Type ty, auto addr = load.getAddr(); auto oldAlloca = addr.getDefiningOp(); - auto alloca = bld.create( - src.getLoc(), cir::PointerType::get(ty), ty, + auto alloca = AllocaOp::create( + bld, src.getLoc(), cir::PointerType::get(ty), ty, /*name=*/llvm::StringRef(""), oldAlloca.getAlignmentAttr()); auto tySize = LF.LM.getDataLayout().getTypeStoreSize(ty); createMemCpy(LF, alloca, addr, tySize.getFixedValue()); - auto newLoad = bld.create(src.getLoc(), alloca.getResult()); + auto newLoad = LoadOp::create(bld, src.getLoc(), alloca.getResult()); bld.replaceAllOpUsesWith(load, newLoad); return newLoad; @@ -435,7 +437,7 @@ mlir::Value castReturnValue(mlir::Value Src, mlir::Type Ty, LowerFunction &LF) { // FIXME: Assert that we aren't truncating non-padding bits when have access // to that information. auto Cast = createCoercedBitcast(Src, Ty, LF); - return LF.getRewriter().create(Src.getLoc(), Cast); + return LoadOp::create(LF.getRewriter(), Src.getLoc(), Cast); } // Otherwise do coercion through memory. @@ -443,7 +445,7 @@ mlir::Value castReturnValue(mlir::Value Src, mlir::Type Ty, LowerFunction &LF) { auto &rewriter = LF.getRewriter(); auto tmp = createTmpAlloca(LF, Src.getLoc(), Ty); createMemCpy(LF, tmp, addr, SrcSize.getFixedValue()); - return rewriter.create(Src.getLoc(), tmp.getResult()); + return LoadOp::create(rewriter, Src.getLoc(), tmp.getResult()); } cir_cconv_unreachable("NYI"); @@ -581,10 +583,10 @@ llvm::LogicalResult LowerFunction::buildFunctionProlog( // the pointer type to be explicitly passed. // FIXME(cir): Get the original name of the argument, as well as the // proper alignment for the given type being allocated. - auto Alloca = rewriter.create( - Fn.getLoc(), cir::PointerType::get(Ty), Ty, - /*name=*/llvm::StringRef(""), - /*alignment=*/rewriter.getI64IntegerAttr(4)); + auto Alloca = + AllocaOp::create(rewriter, Fn.getLoc(), cir::PointerType::get(Ty), Ty, + /*name=*/llvm::StringRef(""), + /*alignment=*/rewriter.getI64IntegerAttr(4)); mlir::Value Ptr = buildAddressAtOffset(*this, Alloca.getResult(), ArgI); @@ -606,9 +608,10 @@ llvm::LogicalResult LowerFunction::buildFunctionProlog( mlir::Value addrToStoreInto; if (srcSize <= dstSize) { - addrToStoreInto = rewriter.create( - Ptr.getLoc(), PointerType::get(STy, ptrType.getAddrSpace()), - CastKind::bitcast, Ptr); + addrToStoreInto = + CastOp::create(rewriter, Ptr.getLoc(), + PointerType::get(STy, ptrType.getAddrSpace()), + CastKind::bitcast, Ptr); } else { addrToStoreInto = createTmpAlloca(*this, Ptr.getLoc(), STy); } @@ -617,12 +620,12 @@ llvm::LogicalResult LowerFunction::buildFunctionProlog( for (unsigned i = 0, e = STy.getNumElements(); i != e; ++i) { mlir::Value ai = Fn.getArgument(FirstIRArg + i); mlir::Type elementTy = STy.getMembers()[i]; - mlir::Value eltPtr = rewriter.create( - ai.getLoc(), + mlir::Value eltPtr = GetMemberOp::create( + rewriter, ai.getLoc(), PointerType::get(elementTy, ptrType.getAddrSpace()), addrToStoreInto, /*name=*/"", /*index=*/i); - rewriter.create(ai.getLoc(), ai, eltPtr); + StoreOp::create(rewriter, ai.getLoc(), ai, eltPtr); } if (srcSize > dstSize) { @@ -682,15 +685,15 @@ llvm::LogicalResult LowerFunction::buildFunctionProlog( rewriter.setInsertionPoint(argAlloca.getDefiningOp()); auto align = LM.getDataLayout().getABITypeAlign(ptrTy); auto alignAttr = rewriter.getI64IntegerAttr(align.value()); - auto newAlloca = rewriter.create( - Fn.getLoc(), cir::PointerType::get(ptrTy), ptrTy, - /*name=*/llvm::StringRef(""), - /*alignment=*/alignAttr); + auto newAlloca = AllocaOp::create(rewriter, Fn.getLoc(), + cir::PointerType::get(ptrTy), ptrTy, + /*name=*/llvm::StringRef(""), + /*alignment=*/alignAttr); - rewriter.create(newAlloca.getLoc(), AI, - newAlloca.getResult()); - auto load = rewriter.create(newAlloca.getLoc(), - newAlloca.getResult()); + StoreOp::create(rewriter, newAlloca.getLoc(), AI, + newAlloca.getResult()); + auto load = LoadOp::create(rewriter, newAlloca.getLoc(), + newAlloca.getResult()); rewriter.replaceAllUsesWith(argAlloca, load); rewriter.eraseOp(firstStore); @@ -884,16 +887,16 @@ void LowerFunction::buildAggregateStore(mlir::Value Val, mlir::Value Dest, LM.getDataLayout().getTypeSizeInBits(pointeeTy)) && "Incompatible types"); auto loc = Val.getLoc(); - Val = rewriter.create(loc, pointeeTy, CastKind::bitcast, Val); + Val = CastOp::create(rewriter, loc, pointeeTy, CastKind::bitcast, Val); } - rewriter.create(Val.getLoc(), Val, Dest); + StoreOp::create(rewriter, Val.getLoc(), Val, Dest); } mlir::Value LowerFunction::buildAggregateBitcast(mlir::Value Val, mlir::Type DestTy) { auto Cast = createCoercedBitcast(Val, DestTy, *this); - return rewriter.create(Val.getLoc(), Cast); + return LoadOp::create(rewriter, Val.getLoc(), Cast); } /// Rewrite a call operation to abide to the ABI calling convention. @@ -1007,9 +1010,9 @@ mlir::Value createAlloca(mlir::Location loc, mlir::Type type, LowerFunction &CGF) { auto align = CGF.LM.getDataLayout().getABITypeAlign(type); auto alignAttr = CGF.getRewriter().getI64IntegerAttr(align.value()); - return CGF.getRewriter().create( - loc, cir::PointerType::get(type), type, - /*name=*/llvm::StringRef(""), alignAttr); + return AllocaOp::create(CGF.getRewriter(), loc, cir::PointerType::get(type), + type, + /*name=*/llvm::StringRef(""), alignAttr); } // NOTE(cir): This method has partial parity to CodeGenFunction's EmitCall @@ -1148,7 +1151,7 @@ mlir::Value LowerFunction::rewriteCallOp(const LowerFunctionInfo &CallInfo, if (SrcSize < DstSize) { auto Alloca = createTmpAlloca(*this, loc, STy); auto SrcAlloca = createTmpAlloca(*this, loc, SrcTy); - rewriter.create(loc, Src, SrcAlloca); + cir::StoreOp::create(rewriter, loc, Src, SrcAlloca); createMemCpy(*this, Alloca, SrcAlloca, SrcSize); Src = Alloca; } else { @@ -1157,10 +1160,11 @@ mlir::Value LowerFunction::rewriteCallOp(const LowerFunctionInfo &CallInfo, assert(NumIRArgs == STy.getNumElements()); for (unsigned I = 0; I != STy.getNumElements(); ++I) { - mlir::Value Member = rewriter.create( - loc, PointerType::get(STy.getMembers()[I]), Src, /*name=*/"", + mlir::Value Member = cir::GetMemberOp::create( + rewriter, loc, PointerType::get(STy.getMembers()[I]), Src, + /*name=*/"", /*index=*/I); - mlir::Value Load = rewriter.create(loc, Member); + mlir::Value Load = cir::LoadOp::create(rewriter, loc, Member); cir_cconv_assert(!cir::MissingFeatures::argHasMaybeUndefAttr()); IRCallArgs[FirstIRArg + I] = Load; } @@ -1257,11 +1261,11 @@ mlir::Value LowerFunction::rewriteCallOp(const LowerFunctionInfo &CallInfo, auto val = Caller.getIndirectCall(); auto ptrTy = PointerType::get(IRFuncTy); auto callee = - rewriter.create(val.getLoc(), ptrTy, CastKind::bitcast, val); - newCallOp = rewriter.create(loc, callee, IRFuncTy, IRCallArgs); + CastOp::create(rewriter, val.getLoc(), ptrTy, CastKind::bitcast, val); + newCallOp = CallOp::create(rewriter, loc, callee, IRFuncTy, IRCallArgs); } else { - newCallOp = rewriter.create(loc, Caller.getCalleeAttr(), - IRFuncTy.getReturnType(), IRCallArgs); + newCallOp = CallOp::create(rewriter, loc, Caller.getCalleeAttr(), + IRFuncTy.getReturnType(), IRCallArgs); } auto extraAttrs = @@ -1355,7 +1359,7 @@ mlir::Value LowerFunction::rewriteCallOp(const LowerFunctionInfo &CallInfo, return RetVal; } case ABIArgInfo::Indirect: { - auto load = rewriter.create(loc, sRetPtr); + auto load = LoadOp::create(rewriter, loc, sRetPtr); return load.getResult(); } default: diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareAArch64CXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareAArch64CXXABI.cpp index b5a82d0500b3..bfbf8a4b8ae2 100644 --- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareAArch64CXXABI.cpp +++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareAArch64CXXABI.cpp @@ -138,12 +138,12 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( // 3 is the field number of __gr_offs, 4 is the field number of __vr_offs if (!IsFPR) { regOffsP = builder.createGetMemberOp(loc, valist, "gr_offs", 3); - regOffs = builder.create(loc, regOffsP); + regOffs = cir::LoadOp::create(builder, loc, regOffsP); regTopIndex = 1; regSize = llvm::alignTo(regSize, 8); } else { regOffsP = builder.createGetMemberOp(loc, valist, "vr_offs", 4); - regOffs = builder.create(loc, regOffsP); + regOffs = cir::LoadOp::create(builder, loc, regOffsP); regTopIndex = 2; regSize = 16 * numRegs; } @@ -156,11 +156,11 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( // argument. We don't want to keep updating regOffs (in case it overflows, // though anyone passing 2GB of arguments, each at most 16 bytes, deserves // whatever they get). - auto zeroValue = builder.create( - loc, cir::IntAttr::get(regOffs.getType(), 0)); - auto usingStack = builder.create(loc, boolTy, cir::CmpOpKind::ge, - regOffs, zeroValue); - builder.create(loc, usingStack, onStackBlock, maybeRegBlock); + auto zeroValue = cir::ConstantOp::create( + builder, loc, cir::IntAttr::get(regOffs.getType(), 0)); + auto usingStack = cir::CmpOp::create(builder, loc, boolTy, cir::CmpOpKind::ge, + regOffs, zeroValue); + cir::BrCondOp::create(builder, loc, usingStack, onStackBlock, maybeRegBlock); auto contBlock = currentBlock->splitBlock(op); // now contBlock should be the block after onStackBlock in CFG. @@ -191,16 +191,17 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( // The fact that this is done unconditionally reflects the fact that // allocating an argument to the stack also uses up all the remaining // registers of the appropriate kind. - auto regSizeValue = builder.create( - loc, cir::IntAttr::get(regOffs.getType(), regSize)); - auto newOffset = builder.create( - loc, regOffs.getType(), cir::BinOpKind::Add, regOffs, regSizeValue); + auto regSizeValue = cir::ConstantOp::create( + builder, loc, cir::IntAttr::get(regOffs.getType(), regSize)); + auto newOffset = + cir::BinOp::create(builder, loc, regOffs.getType(), cir::BinOpKind::Add, + regOffs, regSizeValue); builder.createStore(loc, newOffset, regOffsP); // Now we're in a position to decide whether this argument really was in // registers or not. - auto inRegs = builder.create(loc, boolTy, cir::CmpOpKind::le, - newOffset, zeroValue); - builder.create(loc, inRegs, inRegBlock, onStackBlock); + auto inRegs = cir::CmpOp::create(builder, loc, boolTy, cir::CmpOpKind::le, + newOffset, zeroValue); + cir::BrCondOp::create(builder, loc, inRegs, inRegBlock, onStackBlock); //======================================= // Argument was in registers @@ -210,12 +211,12 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( builder.setInsertionPointToEnd(inRegBlock); auto regTopP = builder.createGetMemberOp( loc, valist, IsFPR ? "vr_top" : "gr_top", regTopIndex); - auto regTop = builder.create(loc, regTopP); + auto regTop = cir::LoadOp::create(builder, loc, regTopP); auto i8Ty = mlir::IntegerType::get(builder.getContext(), 8); auto i8PtrTy = cir::PointerType::get(i8Ty); auto castRegTop = builder.createBitcast(regTop, i8PtrTy); - auto resAsInt8P = builder.create(loc, castRegTop.getType(), - castRegTop, regOffs); + auto resAsInt8P = cir::PtrStrideOp::create(builder, loc, castRegTop.getType(), + castRegTop, regOffs); if (isIndirect) { cir_cconv_assert(!cir::MissingFeatures::handleAArch64Indirect()); @@ -250,11 +251,12 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( if (isBigEndian && !isIndirect && (isHFA || isAggregateTypeForABI) && tySize < slotSize) { clang::CharUnits offset = slotSize - tySize; - auto offsetConst = builder.create( - loc, cir::IntAttr::get(regOffs.getType(), offset.getQuantity())); + auto offsetConst = cir::ConstantOp::create( + builder, loc, + cir::IntAttr::get(regOffs.getType(), offset.getQuantity())); - resAsInt8P = builder.create(loc, castRegTop.getType(), - resAsInt8P, offsetConst); + resAsInt8P = cir::PtrStrideOp::create(builder, loc, castRegTop.getType(), + resAsInt8P, offsetConst); } } @@ -269,7 +271,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( cir_cconv_assert(!cir::MissingFeatures::supportTySizeQueryForAArch64()); cir_cconv_assert(!cir::MissingFeatures::supportTyAlignQueryForAArch64()); - builder.create(loc, mlir::ValueRange{resAsVoidP}, contBlock); + cir::BrOp::create(builder, loc, mlir::ValueRange{resAsVoidP}, contBlock); //======================================= // Argument was on the stack @@ -277,7 +279,7 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( builder.setInsertionPointToEnd(onStackBlock); auto stackP = builder.createGetMemberOp(loc, valist, "stack", 0); - auto onStackPtr = builder.create(loc, stackP); + auto onStackPtr = cir::LoadOp::create(builder, loc, stackP); auto ptrDiffTy = cir::IntType::get(builder.getContext(), 64, /*signed=*/false); @@ -307,26 +309,26 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( cir_cconv_assert(!cir::MissingFeatures::handleBigEndian()); cir_cconv_assert(!cir::MissingFeatures::supportTySizeQueryForAArch64()); - auto stackSizeC = builder.create( - loc, cir::IntAttr::get(ptrDiffTy, stackSize.getQuantity())); + auto stackSizeC = cir::ConstantOp::create( + builder, loc, cir::IntAttr::get(ptrDiffTy, stackSize.getQuantity())); auto castStack = builder.createBitcast(onStackPtr, i8PtrTy); // Write the new value of __stack for the next call to va_arg - auto newStackAsi8Ptr = builder.create( - loc, castStack.getType(), castStack, stackSizeC); + auto newStackAsi8Ptr = cir::PtrStrideOp::create( + builder, loc, castStack.getType(), castStack, stackSizeC); auto newStack = builder.createBitcast(newStackAsi8Ptr, onStackPtr.getType()); builder.createStore(loc, newStack, stackP); if (isBigEndian && !isAggregateTypeForABI && tySize < stackSlotSize) { clang::CharUnits offset = stackSlotSize - tySize; - auto offsetConst = builder.create( - loc, cir::IntAttr::get(ptrDiffTy, offset.getQuantity())); - auto offsetStackAsi8Ptr = builder.create( - loc, castStack.getType(), castStack, offsetConst); + auto offsetConst = cir::ConstantOp::create( + builder, loc, cir::IntAttr::get(ptrDiffTy, offset.getQuantity())); + auto offsetStackAsi8Ptr = cir::PtrStrideOp::create( + builder, loc, castStack.getType(), castStack, offsetConst); auto onStackPtrBE = builder.createBitcast(offsetStackAsi8Ptr, onStackPtr.getType()); - builder.create(loc, mlir::ValueRange{onStackPtrBE}, contBlock); + cir::BrOp::create(builder, loc, mlir::ValueRange{onStackPtrBE}, contBlock); } else { - builder.create(loc, mlir::ValueRange{onStackPtr}, contBlock); + cir::BrOp::create(builder, loc, mlir::ValueRange{onStackPtr}, contBlock); } // generate additional instructions for end block @@ -336,11 +338,11 @@ mlir::Value LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg( cir_cconv_assert(mlir::isa(resP.getType())); auto opResPTy = cir::PointerType::get(opResTy); auto castResP = builder.createBitcast(resP, opResPTy); - auto res = builder.create(loc, castResP); + auto res = cir::LoadOp::create(builder, loc, castResP); // there would be another level of ptr dereference if indirect arg passing cir_cconv_assert(!cir::MissingFeatures::handleAArch64Indirect()); if (isIndirect) { - res = builder.create(loc, res.getResult()); + res = cir::LoadOp::create(builder, loc, res.getResult()); } return res.getResult(); } diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareItaniumCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareItaniumCXXABI.cpp index e2d058401b27..adb6ab63dddf 100644 --- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareItaniumCXXABI.cpp +++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareItaniumCXXABI.cpp @@ -37,7 +37,7 @@ static void buildBadCastCall(CIRBaseBuilderTy &builder, mlir::Location loc, cir_cconv_assert(!MissingFeatures::setCallingConv()); builder.createCallOp(loc, badCastFuncRef, mlir::ValueRange{}); - builder.create(loc); + cir::UnreachableOp::create(builder, loc); builder.clearInsertionPoint(); } @@ -74,10 +74,11 @@ static mlir::Value buildDynamicCastAfterNullCheck(CIRBaseBuilderTy &builder, if (op.isRefcast()) { // Emit a cir.if that checks the casted value. mlir::Value castedValueIsNull = builder.createPtrIsNull(castedPtr); - builder.create( - loc, castedValueIsNull, false, [&](mlir::OpBuilder &, mlir::Location) { - buildBadCastCall(builder, loc, castInfo.getBadCastFunc()); - }); + cir::IfOp::create(builder, loc, castedValueIsNull, false, + [&](mlir::OpBuilder &, mlir::Location) { + buildBadCastCall(builder, loc, + castInfo.getBadCastFunc()); + }); } // Note that castedPtr is a void*. Cast it to a pointer to the destination @@ -118,13 +119,13 @@ buildDynamicCastToVoidAfterNullCheck(CIRBaseBuilderTy &builder, auto vptrTy = cir::VPtrType::get(builder.getContext()); auto vptrPtrTy = builder.getPointerTo(vptrTy); auto vptrPtr = - builder.create(loc, vptrPtrTy, op.getSrc()); + cir::VTableGetVPtrOp::create(builder, loc, vptrPtrTy, op.getSrc()); auto vptr = builder.createLoad(loc, vptrPtr); auto elementPtr = builder.createBitcast(vptr, builder.getPointerTo(vtableElemTy)); auto minusTwo = builder.getSignedInt(loc, -2, 64); - auto offsetToTopSlotPtr = builder.create( - loc, builder.getPointerTo(vtableElemTy), elementPtr, minusTwo); + auto offsetToTopSlotPtr = cir::PtrStrideOp::create( + builder, loc, builder.getPointerTo(vtableElemTy), elementPtr, minusTwo); auto offsetToTop = builder.createAlignedLoad(loc, offsetToTopSlotPtr, vtableElemAlign); @@ -133,7 +134,7 @@ buildDynamicCastToVoidAfterNullCheck(CIRBaseBuilderTy &builder, auto u8PtrTy = builder.getPointerTo(builder.getUIntNTy(8)); auto srcBytePtr = builder.createBitcast(op.getSrc(), u8PtrTy); auto dstBytePtr = - builder.create(loc, u8PtrTy, srcBytePtr, offsetToTop); + cir::PtrStrideOp::create(builder, loc, u8PtrTy, srcBytePtr, offsetToTop); // Cast the result to a void*. return builder.createBitcast(dstBytePtr, builder.getVoidPtrTy()); } @@ -151,20 +152,20 @@ LoweringPrepareItaniumCXXABI::lowerDynamicCast(CIRBaseBuilderTy &builder, return buildDynamicCastAfterNullCheck(builder, op); auto srcValueIsNotNull = builder.createPtrToBoolCast(srcValue); - return builder - .create( - loc, srcValueIsNotNull, - [&](mlir::OpBuilder &, mlir::Location) { - mlir::Value castedValue = - op.isCastToVoid() - ? buildDynamicCastToVoidAfterNullCheck(builder, astCtx, op) - : buildDynamicCastAfterNullCheck(builder, op); - builder.createYield(loc, castedValue); - }, - [&](mlir::OpBuilder &, mlir::Location) { - builder.createYield( - loc, builder.getNullPtr(op.getType(), loc).getResult()); - }) + return cir::TernaryOp::create( + builder, loc, srcValueIsNotNull, + [&](mlir::OpBuilder &, mlir::Location) { + mlir::Value castedValue = + op.isCastToVoid() + ? buildDynamicCastToVoidAfterNullCheck(builder, astCtx, + op) + : buildDynamicCastAfterNullCheck(builder, op); + builder.createYield(loc, castedValue); + }, + [&](mlir::OpBuilder &, mlir::Location) { + builder.createYield( + loc, builder.getNullPtr(op.getType(), loc).getResult()); + }) .getResult(); } diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareX86CXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareX86CXXABI.cpp index b6d118b9bbaa..1092f1730edf 100644 --- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareX86CXXABI.cpp +++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/Targets/LoweringPrepareX86CXXABI.cpp @@ -130,8 +130,8 @@ mlir::Value LoweringPrepareX86CXXABI::lowerVAArgX86_64( ty)); mlir::OpBuilder::InsertPoint scopeIP; - auto scopeOp = builder.create( - loc, + auto scopeOp = cir::ScopeOp::create( + builder, loc, [&](mlir::OpBuilder &opBuilder, mlir::Type &yieldTy, mlir::Location loc) { scopeIP = opBuilder.saveInsertionPoint(); yieldTy = op.getType(); @@ -177,7 +177,7 @@ mlir::Value LoweringPrepareX86CXXABI::lowerVAArgX86_64( mlir::Block *inRegBlock = builder.createBlock(contBlock); mlir::Block *inMemBlock = builder.createBlock(contBlock); builder.setInsertionPointToEnd(currentBlock); - builder.create(loc, inRegs, inRegBlock, inMemBlock); + BrCondOp::create(builder, loc, inRegs, inRegBlock, inMemBlock); // Emit code to load the value if it was passed in registers. builder.setInsertionPointToStart(inRegBlock); @@ -340,13 +340,13 @@ mlir::Value LoweringPrepareX86CXXABI::lowerVAArgX86_64( builder.createStore(loc, builder.createAdd(fp_offset, offset), fp_offset_p); } - builder.create(loc, mlir::ValueRange{regAddr}, contBlock); + BrOp::create(builder, loc, mlir::ValueRange{regAddr}, contBlock); // Emit code to load the value if it was passed in memory. builder.setInsertionPointToStart(inMemBlock); mlir::Value memAddr = buildX86_64VAArgFromMemory(builder, datalayout, valist, ty, loc); - builder.create(loc, mlir::ValueRange{memAddr}, contBlock); + BrOp::create(builder, loc, mlir::ValueRange{memAddr}, contBlock); // Yield the appropriate result. builder.setInsertionPointToStart(contBlock); @@ -358,7 +358,7 @@ mlir::Value LoweringPrepareX86CXXABI::lowerVAArgX86_64( loc, builder.createPtrBitcast(res_addr, ty), alignment) : builder.createLoad(loc, builder.createPtrBitcast(res_addr, ty)); - builder.create(loc, result); + cir::YieldOp::create(builder, loc, result); return scopeOp.getResult(0); } diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 25469eeca4ed..c790e152b90e 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -184,7 +184,7 @@ void getOrCreateLLVMFuncOp(mlir::ConversionPatternRewriter &rewriter, if (!sourceSymbol) { mlir::OpBuilder::InsertionGuard guard(rewriter); rewriter.setInsertionPoint(enclosingFnOp); - rewriter.create(srcOp->getLoc(), fnName, fnTy); + mlir::LLVM::LLVMFuncOp::create(rewriter, srcOp->getLoc(), fnName, fnTy); } } @@ -200,8 +200,8 @@ getAnnotationStringGlobal(mlir::StringAttr strAttr, mlir::ModuleOp &module, if (!globalsMap.contains(str)) { auto llvmStrTy = mlir::LLVM::LLVMArrayType::get( mlir::IntegerType::get(module.getContext(), 8), str.size() + 1); - auto strGlobalOp = globalVarBuilder.create( - loc, llvmStrTy, + auto strGlobalOp = mlir::LLVM::GlobalOp::create( + globalVarBuilder, loc, llvmStrTy, /*isConstant=*/true, mlir::LLVM::Linkage::Private, ".str" + (globalsMap.empty() ? "" @@ -250,8 +250,8 @@ mlir::LLVM::GlobalOp getOrCreateAnnotationArgsVar( mlir::LLVM::LLVMStructType argsStructTy = mlir::LLVM::LLVMStructType::getLiteral(globalVarBuilder.getContext(), argStrutFldTypes); - auto argsGlobalOp = globalVarBuilder.create( - loc, argsStructTy, true, mlir::LLVM::Linkage::Private, + auto argsGlobalOp = mlir::LLVM::GlobalOp::create( + globalVarBuilder, loc, argsStructTy, true, mlir::LLVM::Linkage::Private, ".args" + (argsVarMap.empty() ? "" : "." + std::to_string(argsVarMap.size())) + ".annotation", @@ -266,7 +266,7 @@ mlir::LLVM::GlobalOp getOrCreateAnnotationArgsVar( argsInitBuilder.setInsertionPointToEnd(argsGlobalOp.getInitializerBlock()); mlir::Value argsStructInit = - argsInitBuilder.create(loc, argsStructTy); + mlir::LLVM::UndefOp::create(argsInitBuilder, loc, argsStructTy); int idx = 0; for (mlir::Attribute arg : argsAttr) { if (auto strArgAttr = mlir::dyn_cast(arg)) { @@ -275,20 +275,20 @@ mlir::LLVM::GlobalOp getOrCreateAnnotationArgsVar( // created in the previous loop. mlir::LLVM::GlobalOp argStrVar = getAnnotationStringGlobal( strArgAttr, module, argStringGlobalsMap, globalVarBuilder, loc, true); - auto argStrVarAddr = argsInitBuilder.create( - loc, annoPtrTy, argStrVar.getSymName()); - argsStructInit = argsInitBuilder.create( - loc, argsStructInit, argStrVarAddr, idx++); + auto argStrVarAddr = mlir::LLVM::AddressOfOp::create( + argsInitBuilder, loc, annoPtrTy, argStrVar.getSymName()); + argsStructInit = mlir::LLVM::InsertValueOp::create( + argsInitBuilder, loc, argsStructInit, argStrVarAddr, idx++); } else if (auto intArgAttr = mlir::dyn_cast(arg)) { - auto intArgFld = argsInitBuilder.create( - loc, intArgAttr.getType(), intArgAttr.getValue()); - argsStructInit = argsInitBuilder.create( - loc, argsStructInit, intArgFld, idx++); + auto intArgFld = mlir::LLVM::ConstantOp::create( + argsInitBuilder, loc, intArgAttr.getType(), intArgAttr.getValue()); + argsStructInit = mlir::LLVM::InsertValueOp::create( + argsInitBuilder, loc, argsStructInit, intArgFld, idx++); } else { llvm_unreachable("Unsupported annotation arg type"); } } - argsInitBuilder.create(loc, argsStructInit); + mlir::LLVM::ReturnOp::create(argsInitBuilder, loc, argsStructInit); argsVarMap[argsAttr] = argsGlobalOp; return argsGlobalOp; } @@ -312,8 +312,8 @@ void lowerAnnotationValue( // The second field is ptr to the annotation name mlir::StringAttr annotationName = annotation.getName(); - auto annotationNameFld = varInitBuilder.create( - localLoc, annoPtrTy, + auto annotationNameFld = mlir::LLVM::AddressOfOp::create( + varInitBuilder, localLoc, annoPtrTy, getAnnotationStringGlobal(annotationName, module, stringGlobalsMap, globalVarBuilder, localLoc) .getSymName()); @@ -330,30 +330,30 @@ void lowerAnnotationValue( // To be consistent with clang code gen, we add trailing null char auto fileName = mlir::StringAttr::get( module.getContext(), std::string(annotFileLoc.getFilename().getValue())); - auto fileNameFld = varInitBuilder.create( - localLoc, annoPtrTy, + auto fileNameFld = mlir::LLVM::AddressOfOp::create( + varInitBuilder, localLoc, annoPtrTy, getAnnotationStringGlobal(fileName, module, stringGlobalsMap, globalVarBuilder, localLoc) .getSymName()); outVals.push_back(fileNameFld->getResult(0)); unsigned int lineNo = annotFileLoc.getLine(); - auto lineNoFld = varInitBuilder.create( - localLoc, globalVarBuilder.getI32Type(), lineNo); + auto lineNoFld = mlir::LLVM::ConstantOp::create( + varInitBuilder, localLoc, globalVarBuilder.getI32Type(), lineNo); outVals.push_back(lineNoFld->getResult(0)); // The fifth field is ptr to the annotation args var, it could be null if (annotation.isNoArgs()) { auto nullPtrFld = - varInitBuilder.create(localLoc, annoPtrTy); + mlir::LLVM::ZeroOp::create(varInitBuilder, localLoc, annoPtrTy); outVals.push_back(nullPtrFld->getResult(0)); } else { mlir::ArrayAttr argsAttr = annotation.getArgs(); mlir::LLVM::GlobalOp annotArgsVar = getOrCreateAnnotationArgsVar(localLoc, module, globalVarBuilder, argStringGlobalsMap, argsVarMap, argsAttr); - auto argsVarView = varInitBuilder.create( - localLoc, annoPtrTy, annotArgsVar.getSymName()); + auto argsVarView = mlir::LLVM::AddressOfOp::create( + varInitBuilder, localLoc, annoPtrTy, annotArgsVar.getSymName()); outVals.push_back(argsVarView->getResult(0)); } } @@ -498,71 +498,76 @@ class CirAttrToValue { /// IntAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::IntAttr intAttr) { auto loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(intAttr.getType()), intAttr.getValue()); + return mlir::LLVM::ConstantOp::create( + rewriter, loc, converter->convertType(intAttr.getType()), + intAttr.getValue()); } /// BoolAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::BoolAttr boolAttr) { auto loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(boolAttr.getType()), boolAttr.getValue()); + return mlir::LLVM::ConstantOp::create( + rewriter, loc, converter->convertType(boolAttr.getType()), + boolAttr.getValue()); } /// ConstPtrAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::ConstPtrAttr ptrAttr) { auto loc = parentOp->getLoc(); if (ptrAttr.isNullValue()) { - return rewriter.create( - loc, converter->convertType(ptrAttr.getType())); + return mlir::LLVM::ZeroOp::create( + rewriter, loc, converter->convertType(ptrAttr.getType())); } mlir::DataLayout layout(parentOp->getParentOfType()); - mlir::Value ptrVal = rewriter.create( - loc, rewriter.getIntegerType(layout.getTypeSizeInBits(ptrAttr.getType())), + mlir::Value ptrVal = mlir::LLVM::ConstantOp::create( + rewriter, loc, + rewriter.getIntegerType(layout.getTypeSizeInBits(ptrAttr.getType())), ptrAttr.getValue().getInt()); - return rewriter.create( - loc, converter->convertType(ptrAttr.getType()), ptrVal); + return mlir::LLVM::IntToPtrOp::create( + rewriter, loc, converter->convertType(ptrAttr.getType()), ptrVal); } /// FPAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::FPAttr fltAttr) { auto loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(fltAttr.getType()), fltAttr.getValue()); + return mlir::LLVM::ConstantOp::create( + rewriter, loc, converter->convertType(fltAttr.getType()), + fltAttr.getValue()); } /// ZeroAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::ZeroAttr zeroAttr) { auto loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(zeroAttr.getType())); + return mlir::LLVM::ZeroOp::create(rewriter, loc, + converter->convertType(zeroAttr.getType())); } /// UndefAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::UndefAttr undefAttr) { auto loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(undefAttr.getType())); + return mlir::LLVM::UndefOp::create( + rewriter, loc, converter->convertType(undefAttr.getType())); } /// PoisonAttr visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::PoisonAttr poisonAttr) { auto loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(poisonAttr.getType())); + return mlir::LLVM::PoisonOp::create( + rewriter, loc, converter->convertType(poisonAttr.getType())); } /// ConstRecord visitor. mlir::Value CirAttrToValue::visitCirAttr(cir::ConstRecordAttr constRecord) { auto llvmTy = converter->convertType(constRecord.getType()); auto loc = parentOp->getLoc(); - mlir::Value result = rewriter.create(loc, llvmTy); + mlir::Value result = mlir::LLVM::UndefOp::create(rewriter, loc, llvmTy); // Iteratively lower each constant element of the record. for (auto [idx, elt] : llvm::enumerate(constRecord.getMembers())) { mlir::Value init = emitCirAttrToMemory(parentOp, elt, rewriter, converter, dataLayout); - result = rewriter.create(loc, result, init, idx); + result = + mlir::LLVM::InsertValueOp::create(rewriter, loc, result, init, idx); } return result; @@ -572,11 +577,12 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ConstRecordAttr constRecord) { mlir::Value CirAttrToValue::visitCirAttr(cir::VTableAttr vtableArr) { auto llvmTy = converter->convertType(vtableArr.getType()); auto loc = parentOp->getLoc(); - mlir::Value result = rewriter.create(loc, llvmTy); + mlir::Value result = mlir::LLVM::UndefOp::create(rewriter, loc, llvmTy); for (auto [idx, elt] : llvm::enumerate(vtableArr.getVtableData())) { mlir::Value init = visit(elt); - result = rewriter.create(loc, result, init, idx); + result = + mlir::LLVM::InsertValueOp::create(rewriter, loc, result, init, idx); } return result; @@ -586,11 +592,12 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::VTableAttr vtableArr) { mlir::Value CirAttrToValue::visitCirAttr(cir::TypeInfoAttr typeinfoArr) { auto llvmTy = converter->convertType(typeinfoArr.getType()); auto loc = parentOp->getLoc(); - mlir::Value result = rewriter.create(loc, llvmTy); + mlir::Value result = mlir::LLVM::UndefOp::create(rewriter, loc, llvmTy); for (auto [idx, elt] : llvm::enumerate(typeinfoArr.getData())) { mlir::Value init = visit(elt); - result = rewriter.create(loc, result, init, idx); + result = + mlir::LLVM::InsertValueOp::create(rewriter, loc, result, init, idx); } return result; @@ -604,10 +611,10 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ConstArrayAttr constArr) { if (constArr.getTrailingZerosNum() > 0) { auto arrayTy = constArr.getType(); - result = rewriter.create( - loc, converter->convertType(arrayTy)); + result = mlir::LLVM::ZeroOp::create(rewriter, loc, + converter->convertType(arrayTy)); } else { - result = rewriter.create(loc, llvmTy); + result = mlir::LLVM::UndefOp::create(rewriter, loc, llvmTy); } // Iteratively lower each constant element of the array. @@ -616,7 +623,7 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ConstArrayAttr constArr) { mlir::Value init = emitCirAttrToMemory(parentOp, elt, rewriter, converter, dataLayout); result = - rewriter.create(loc, result, init, idx); + mlir::LLVM::InsertValueOp::create(rewriter, loc, result, init, idx); } } // TODO(cir): this diverges from traditional lowering. Normally the string @@ -627,10 +634,10 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ConstArrayAttr constArr) { assert(arrayTy && "String attribute must have an array type"); auto eltTy = arrayTy.getElementType(); for (auto [idx, elt] : llvm::enumerate(strAttr)) { - auto init = rewriter.create( - loc, converter->convertType(eltTy), elt); + auto init = mlir::LLVM::ConstantOp::create( + rewriter, loc, converter->convertType(eltTy), elt); result = - rewriter.create(loc, result, init, idx); + mlir::LLVM::InsertValueOp::create(rewriter, loc, result, init, idx); } } else { llvm_unreachable("unexpected ConstArrayAttr elements"); @@ -658,8 +665,8 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ConstVectorAttr constVec) { } mlirValues.push_back(mlirAttr); } - return rewriter.create( - loc, llvmTy, + return mlir::LLVM::ConstantOp::create( + rewriter, loc, llvmTy, mlir::DenseElementsAttr::get(mlir::cast(llvmTy), mlirValues)); } @@ -687,8 +694,8 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ComplexAttr complexAttr) { } mlir::Location loc = parentOp->getLoc(); - return rewriter.create( - loc, converter->convertType(complexAttr.getType()), + return mlir::LLVM::ConstantOp::create( + rewriter, loc, converter->convertType(complexAttr.getType()), rewriter.getArrayAttr(components)); } // GlobalViewAttr visitor. @@ -729,8 +736,8 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::GlobalViewAttr globalAttr) { } auto loc = parentOp->getLoc(); - mlir::Value addrOp = rewriter.create( - loc, + mlir::Value addrOp = mlir::LLVM::AddressOfOp::create( + rewriter, loc, mlir::LLVM::LLVMPointerType::get(rewriter.getContext(), sourceAddrSpace), symName); @@ -747,15 +754,15 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::GlobalViewAttr globalAttr) { } auto resTy = addrOp.getType(); auto eltTy = converter->convertType(sourceType); - addrOp = rewriter.create( - loc, resTy, eltTy, addrOp, indices, - mlir::LLVM::GEPNoWrapFlags::inbounds); + addrOp = + mlir::LLVM::GEPOp::create(rewriter, loc, resTy, eltTy, addrOp, indices, + mlir::LLVM::GEPNoWrapFlags::inbounds); } if (auto intTy = mlir::dyn_cast(globalAttr.getType())) { auto llvmDstTy = converter->convertType(globalAttr.getType()); - return rewriter.create(parentOp->getLoc(), - llvmDstTy, addrOp); + return mlir::LLVM::PtrToIntOp::create(rewriter, parentOp->getLoc(), + llvmDstTy, addrOp); } if (auto ptrTy = mlir::dyn_cast(globalAttr.getType())) { @@ -766,8 +773,8 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::GlobalViewAttr globalAttr) { return addrOp; auto llvmDstTy = converter->convertType(globalAttr.getType()); - return rewriter.create(parentOp->getLoc(), llvmDstTy, - addrOp); + return mlir::LLVM::BitcastOp::create(rewriter, parentOp->getLoc(), + llvmDstTy, addrOp); } llvm_unreachable("Expecting pointer or integer type for GlobalViewAttr"); @@ -871,8 +878,8 @@ void convertSideEffectForCall(mlir::Operation *callOp, mlir::LogicalResult CIRToLLVMCopyOpLowering::matchAndRewrite( cir::CopyOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - const mlir::Value length = rewriter.create( - op.getLoc(), rewriter.getI32Type(), op.getLength()); + const mlir::Value length = mlir::LLVM::ConstantOp::create( + rewriter, op.getLoc(), rewriter.getI32Type(), op.getLength()); rewriter.replaceOpWithNewOp( op, adaptor.getDst(), adaptor.getSrc(), length, op.getIsVolatile()); return mlir::success(); @@ -929,8 +936,8 @@ mlir::LogicalResult CIRToLLVMMemCpyInlineOpLowering::matchAndRewrite( mlir::LogicalResult CIRToLLVMMemSetOpLowering::matchAndRewrite( cir::MemSetOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - auto converted = rewriter.create( - op.getLoc(), mlir::IntegerType::get(op.getContext(), 8), + auto converted = mlir::LLVM::TruncOp::create( + rewriter, op.getLoc(), mlir::IntegerType::get(op.getContext(), 8), adaptor.getVal()); rewriter.replaceOpWithNewOp(op, adaptor.getDst(), converted, adaptor.getLen(), @@ -941,8 +948,8 @@ mlir::LogicalResult CIRToLLVMMemSetOpLowering::matchAndRewrite( mlir::LogicalResult CIRToLLVMMemSetInlineOpLowering::matchAndRewrite( cir::MemSetInlineOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - auto converted = rewriter.create( - op.getLoc(), mlir::IntegerType::get(op.getContext(), 8), + auto converted = mlir::LLVM::TruncOp::create( + rewriter, op.getLoc(), mlir::IntegerType::get(op.getContext(), 8), adaptor.getVal()); rewriter.replaceOpWithNewOp( op, adaptor.getDst(), converted, adaptor.getLenAttr(), @@ -960,12 +967,12 @@ static mlir::Value getLLVMIntCast(mlir::ConversionPatternRewriter &rewriter, auto loc = llvmSrc.getLoc(); if (cirSrcWidth < cirDstIntWidth) { if (isUnsigned) - return rewriter.create(loc, llvmDstIntTy, llvmSrc); - return rewriter.create(loc, llvmDstIntTy, llvmSrc); + return mlir::LLVM::ZExtOp::create(rewriter, loc, llvmDstIntTy, llvmSrc); + return mlir::LLVM::SExtOp::create(rewriter, loc, llvmDstIntTy, llvmSrc); } // Otherwise truncate - return rewriter.create(loc, llvmDstIntTy, llvmSrc); + return mlir::LLVM::TruncOp::create(rewriter, loc, llvmDstIntTy, llvmSrc); } static mlir::Value promoteIndex(mlir::ConversionPatternRewriter &rewriter, @@ -1001,10 +1008,10 @@ static mlir::Value promoteIndex(mlir::ConversionPatternRewriter &rewriter, layoutWidth); if (rewriteSub) { - index = rewriter.create( - index.getLoc(), - rewriter.create(index.getLoc(), index.getType(), - 0), + index = mlir::LLVM::SubOp::create( + rewriter, index.getLoc(), + mlir::LLVM::ConstantOp::create(rewriter, index.getLoc(), + index.getType(), 0), index); // TODO: check if the sub is trivially dead now. rewriter.eraseOp(sub); @@ -1108,11 +1115,11 @@ mlir::LogicalResult CIRToLLVMBaseClassAddrOpLowering::matchAndRewrite( baseClassOp, resultType, byteType, derivedAddr, offset); } else { auto loc = baseClassOp.getLoc(); - mlir::Value isNull = rewriter.create( - loc, mlir::LLVM::ICmpPredicate::eq, derivedAddr, - rewriter.create(loc, derivedAddr.getType())); - mlir::Value adjusted = rewriter.create( - loc, resultType, byteType, derivedAddr, offset); + mlir::Value isNull = mlir::LLVM::ICmpOp::create( + rewriter, loc, mlir::LLVM::ICmpPredicate::eq, derivedAddr, + mlir::LLVM::ZeroOp::create(rewriter, loc, derivedAddr.getType())); + mlir::Value adjusted = mlir::LLVM::GEPOp::create( + rewriter, loc, resultType, byteType, derivedAddr, offset); rewriter.replaceOpWithNewOp(baseClassOp, isNull, derivedAddr, adjusted); } @@ -1134,11 +1141,11 @@ mlir::LogicalResult CIRToLLVMDerivedClassAddrOpLowering::matchAndRewrite( byteType, baseAddr, offset); } else { auto loc = derivedClassOp.getLoc(); - mlir::Value isNull = rewriter.create( - loc, mlir::LLVM::ICmpPredicate::eq, baseAddr, - rewriter.create(loc, baseAddr.getType())); - mlir::Value adjusted = rewriter.create( - loc, resultType, byteType, baseAddr, offset); + mlir::Value isNull = mlir::LLVM::ICmpOp::create( + rewriter, loc, mlir::LLVM::ICmpPredicate::eq, baseAddr, + mlir::LLVM::ZeroOp::create(rewriter, loc, baseAddr.getType())); + mlir::Value adjusted = mlir::LLVM::GEPOp::create( + rewriter, loc, resultType, byteType, baseAddr, offset); rewriter.replaceOpWithNewOp(derivedClassOp, isNull, baseAddr, adjusted); } @@ -1193,9 +1200,9 @@ getValueForVTableSymbol(mlir::Operation *op, } else if (auto cirSymbol = dyn_cast(symbol)) { eltType = converter->convertType(cirSymbol.getSymType()); } - return rewriter.create( - op->getLoc(), mlir::LLVM::LLVMPointerType::get(op->getContext()), - nameAttr.getValue()); + return mlir::LLVM::AddressOfOp::create( + rewriter, op->getLoc(), + mlir::LLVM::LLVMPointerType::get(op->getContext()), nameAttr.getValue()); } mlir::LogicalResult CIRToLLVMVTTAddrPointOpLowering::matchAndRewrite( @@ -1282,8 +1289,9 @@ mlir::LogicalResult CIRToLLVMCastOpLowering::matchAndRewrite( break; } case cir::CastKind::int_to_bool: { - auto zero = rewriter.create( - src.getLoc(), cir::IntAttr::get(castOp.getSrc().getType(), 0)); + auto zero = cir::ConstantOp::create( + rewriter, src.getLoc(), + cir::IntAttr::get(castOp.getSrc().getType(), 0)); rewriter.replaceOpWithNewOp( castOp, cir::BoolType::get(getContext()), cir::CmpOpKind::ne, castOp.getSrc(), zero); @@ -1348,8 +1356,8 @@ mlir::LogicalResult CIRToLLVMCastOpLowering::matchAndRewrite( auto kind = mlir::LLVM::FCmpPredicate::une; // Check if float is not equal to zero. - auto zeroFloat = rewriter.create( - castOp.getLoc(), llvmSrcVal.getType(), + auto zeroFloat = mlir::LLVM::ConstantOp::create( + rewriter, castOp.getLoc(), llvmSrcVal.getType(), mlir::FloatAttr::get(llvmSrcVal.getType(), 0.0)); // Extend comparison result to either bool (C++) or int (C). @@ -1430,8 +1438,9 @@ mlir::LogicalResult CIRToLLVMCastOpLowering::matchAndRewrite( } case cir::CastKind::ptr_to_bool: { auto zero = rewriter.getI64IntegerAttr(0); - auto null = rewriter.create( - src.getLoc(), cir::ConstPtrAttr::get(castOp.getSrc().getType(), zero)); + auto null = cir::ConstantOp::create( + rewriter, src.getLoc(), + cir::ConstPtrAttr::get(castOp.getSrc().getType(), zero)); rewriter.replaceOpWithNewOp( castOp, cir::BoolType::get(getContext()), cir::CmpOpKind::ne, castOp.getSrc(), null); @@ -1541,11 +1550,9 @@ rewriteToCallOrInvoke(mlir::Operation *op, mlir::ValueRange callOperands, // This all gets sorted out when the LLVM dialect is lowered to LLVM IR. auto symAttr = cast(calleeAttr); auto addrOfAlias = - rewriter - .create( - op->getLoc(), - mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), - symAttr) + mlir::LLVM::AddressOfOp::create( + rewriter, op->getLoc(), + mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), symAttr) .getResult(); adjustedCallOperands.push_back(addrOfAlias); @@ -1646,8 +1653,9 @@ mlir::LogicalResult CIRToLLVMEhInflightOpLowering::matchAndRewrite( // operations in the LLVM function entry basic block. mlir::OpBuilder::InsertionGuard guard(rewriter); rewriter.setInsertionPointToStart(entryBlock); - mlir::Value addrOp = rewriter.create( - loc, mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), + mlir::Value addrOp = mlir::LLVM::AddressOfOp::create( + rewriter, loc, + mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), symAttr.getValue()); symAddrs.push_back(addrOp); } @@ -1656,16 +1664,17 @@ mlir::LogicalResult CIRToLLVMEhInflightOpLowering::matchAndRewrite( // catch ptr null mlir::OpBuilder::InsertionGuard guard(rewriter); rewriter.setInsertionPointToStart(entryBlock); - mlir::Value nullOp = rewriter.create( - loc, mlir::LLVM::LLVMPointerType::get(rewriter.getContext())); + mlir::Value nullOp = mlir::LLVM::ZeroOp::create( + rewriter, loc, + mlir::LLVM::LLVMPointerType::get(rewriter.getContext())); symAddrs.push_back(nullOp); } } // %slot = extractvalue { ptr, i32 } %x, 0 // %selector = extractvalue { ptr, i32 } %x, 1 - auto padOp = rewriter.create( - loc, llvmLandingPadStructTy, symAddrs); + auto padOp = mlir::LLVM::LandingpadOp::create( + rewriter, loc, llvmLandingPadStructTy, symAddrs); SmallVector slotIdx = {0}; SmallVector selectorIdx = {1}; @@ -1673,9 +1682,9 @@ mlir::LogicalResult CIRToLLVMEhInflightOpLowering::matchAndRewrite( padOp.setCleanup(true); mlir::Value slot = - rewriter.create(loc, padOp, slotIdx); + mlir::LLVM::ExtractValueOp::create(rewriter, loc, padOp, slotIdx); mlir::Value selector = - rewriter.create(loc, padOp, selectorIdx); + mlir::LLVM::ExtractValueOp::create(rewriter, loc, padOp, selectorIdx); rewriter.replaceOp(op, mlir::ValueRange{slot, selector}); @@ -1721,9 +1730,9 @@ void CIRToLLVMAllocaOpLowering::buildAllocaAnnotations( lowerAnnotationValue(loc, loc, annot, module, varInitBuilder, globalVarBuilder, stringGlobalsMap, argStringGlobalsMap, argsVarMap, intrinsicArgs); - rewriter.create( - loc, intrinRetTy, mlir::StringAttr::get(getContext(), intrinNameAttr), - intrinsicArgs); + mlir::LLVM::CallIntrinsicOp::create( + rewriter, loc, intrinRetTy, + mlir::StringAttr::get(getContext(), intrinNameAttr), intrinsicArgs); } } @@ -1732,8 +1741,8 @@ mlir::LogicalResult CIRToLLVMAllocaOpLowering::matchAndRewrite( mlir::ConversionPatternRewriter &rewriter) const { mlir::Value size = op.isDynamic() ? adaptor.getDynAllocSize() - : rewriter.create( - op.getLoc(), + : mlir::LLVM::ConstantOp::create( + rewriter, op.getLoc(), typeConverter->convertType(rewriter.getIndexType()), rewriter.getIntegerAttr(rewriter.getIndexType(), 1)); auto elementTy = @@ -1820,9 +1829,10 @@ mlir::LogicalResult CIRToLLVMLoadOpLowering::matchAndRewrite( invariant = isLoadOrStoreInvariant(op.getAddr()); // TODO: nontemporal, syncscope. - auto newLoad = rewriter.create( - op->getLoc(), llvmTy, adaptor.getAddr(), /* alignment */ alignment, - op.getIsVolatile(), /* nontemporal */ op.getIsNontemporal(), + auto newLoad = mlir::LLVM::LoadOp::create( + rewriter, op->getLoc(), llvmTy, adaptor.getAddr(), + /* alignment */ alignment, op.getIsVolatile(), + /* nontemporal */ op.getIsNontemporal(), /* invariant */ false, /* invariantGroup */ invariant, ordering); // Convert adapted result to its original type if needed. @@ -1862,8 +1872,9 @@ mlir::LogicalResult CIRToLLVMStoreOpLowering::matchAndRewrite( mlir::Value value = emitToMemory(rewriter, dataLayout, op.getValue().getType(), adaptor.getValue()); // TODO: nontemporal, syncscope. - auto storeOp = rewriter.create( - op->getLoc(), value, adaptor.getAddr(), alignment, op.getIsVolatile(), + auto storeOp = mlir::LLVM::StoreOp::create( + rewriter, op->getLoc(), value, adaptor.getAddr(), alignment, + op.getIsVolatile(), /* nontemporal */ op.getIsNontemporal(), /* invariantGroup */ invariant, ordering); rewriter.replaceOp(op, storeOp); @@ -2058,15 +2069,15 @@ mlir::LogicalResult CIRToLLVMVecCreateOpLowering::matchAndRewrite( assert(vecTy && "result type of cir.vec.create op is not VectorType"); auto llvmTy = typeConverter->convertType(vecTy); auto loc = op.getLoc(); - mlir::Value result = rewriter.create(loc, llvmTy); + mlir::Value result = mlir::LLVM::PoisonOp::create(rewriter, loc, llvmTy); assert(vecTy.getSize() == op.getElements().size() && "cir.vec.create op count doesn't match vector type elements count"); for (uint64_t i = 0; i < vecTy.getSize(); ++i) { mlir::Value indexValue = - rewriter.create(loc, rewriter.getI64Type(), i); - result = rewriter.create( - loc, result, adaptor.getElements()[i], indexValue); + mlir::LLVM::ConstantOp::create(rewriter, loc, rewriter.getI64Type(), i); + result = mlir::LLVM::InsertElementOp::create( + rewriter, loc, result, adaptor.getElements()[i], indexValue); } rewriter.replaceOp(op, result); return mlir::success(); @@ -2080,13 +2091,13 @@ mlir::LogicalResult CIRToLLVMVecCmpOpLowering::matchAndRewrite( auto elementType = elementTypeIfVector(op.getLhs().getType()); mlir::Value bitResult; if (auto intType = mlir::dyn_cast(elementType)) { - bitResult = rewriter.create( - op.getLoc(), + bitResult = mlir::LLVM::ICmpOp::create( + rewriter, op.getLoc(), convertCmpKindToICmpPredicate(op.getKind(), intType.isSigned()), adaptor.getLhs(), adaptor.getRhs()); } else if (mlir::isa(elementType)) { - bitResult = rewriter.create( - op.getLoc(), convertCmpKindToFCmpPredicate(op.getKind()), + bitResult = mlir::LLVM::FCmpOp::create( + rewriter, op.getLoc(), convertCmpKindToFCmpPredicate(op.getKind()), adaptor.getLhs(), adaptor.getRhs()); } else { return op.emitError() << "unsupported type for VecCmpOp: " << elementType; @@ -2114,9 +2125,9 @@ mlir::LogicalResult CIRToLLVMVecSplatOpLowering::matchAndRewrite( assert(vecTy && "result type of cir.vec.splat op is not VectorType"); auto llvmTy = typeConverter->convertType(vecTy); auto loc = op.getLoc(); - mlir::Value poison = rewriter.create(loc, llvmTy); + mlir::Value poison = mlir::LLVM::PoisonOp::create(rewriter, loc, llvmTy); mlir::Value indexValue = - rewriter.create(loc, rewriter.getI64Type(), 0); + mlir::LLVM::ConstantOp::create(rewriter, loc, rewriter.getI64Type(), 0); mlir::Value elementValue = adaptor.getValue(); if (elementValue.getDefiningOp()) { // If the splat value is poison, then we can just use poison value @@ -2124,11 +2135,11 @@ mlir::LogicalResult CIRToLLVMVecSplatOpLowering::matchAndRewrite( rewriter.replaceOp(op, poison); return mlir::success(); } - mlir::Value oneElement = rewriter.create( - loc, poison, elementValue, indexValue); + mlir::Value oneElement = mlir::LLVM::InsertElementOp::create( + rewriter, loc, poison, elementValue, indexValue); SmallVector zeroValues(vecTy.getSize(), 0); - mlir::Value shuffled = rewriter.create( - loc, oneElement, poison, zeroValues); + mlir::Value shuffled = mlir::LLVM::ShuffleVectorOp::create( + rewriter, loc, oneElement, poison, zeroValues); rewriter.replaceOp(op, shuffled); return mlir::success(); } @@ -2137,10 +2148,10 @@ mlir::LogicalResult CIRToLLVMVecTernaryOpLowering::matchAndRewrite( cir::VecTernaryOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { // Convert `cond` into a vector of i1, then use that in a `select` op. - mlir::Value bitVec = rewriter.create( - op.getLoc(), mlir::LLVM::ICmpPredicate::ne, adaptor.getCond(), - rewriter.create( - op.getCond().getLoc(), + mlir::Value bitVec = mlir::LLVM::ICmpOp::create( + rewriter, op.getLoc(), mlir::LLVM::ICmpPredicate::ne, adaptor.getCond(), + mlir::LLVM::ZeroOp::create( + rewriter, op.getCond().getLoc(), typeConverter->convertType(op.getCond().getType()))); rewriter.replaceOpWithNewOp( op, bitVec, adaptor.getLhs(), adaptor.getRhs()); @@ -2188,28 +2199,28 @@ mlir::LogicalResult CIRToLLVMVecShuffleDynamicOpLowering::matchAndRewrite( mlir::cast(op.getVec().getType()).getSize(); uint64_t maskBits = llvm::NextPowerOf2(numElements - 1) - 1; mlir::Value maskValue = - rewriter.create(loc, llvmIndexType, maskBits); + mlir::LLVM::ConstantOp::create(rewriter, loc, llvmIndexType, maskBits); mlir::Value maskVector = - rewriter.create(loc, llvmIndexVecType); + mlir::LLVM::UndefOp::create(rewriter, loc, llvmIndexVecType); for (uint64_t i = 0; i < numElements; ++i) { mlir::Value iValue = - rewriter.create(loc, rewriter.getI64Type(), i); - maskVector = rewriter.create( - loc, maskVector, maskValue, iValue); - } - mlir::Value maskedIndices = rewriter.create( - loc, llvmIndexVecType, adaptor.getIndices(), maskVector); - mlir::Value result = rewriter.create( - loc, getTypeConverter()->convertType(op.getVec().getType())); + mlir::LLVM::ConstantOp::create(rewriter, loc, rewriter.getI64Type(), i); + maskVector = mlir::LLVM::InsertElementOp::create(rewriter, loc, maskVector, + maskValue, iValue); + } + mlir::Value maskedIndices = mlir::LLVM::AndOp::create( + rewriter, loc, llvmIndexVecType, adaptor.getIndices(), maskVector); + mlir::Value result = mlir::LLVM::UndefOp::create( + rewriter, loc, getTypeConverter()->convertType(op.getVec().getType())); for (uint64_t i = 0; i < numElements; ++i) { mlir::Value iValue = - rewriter.create(loc, rewriter.getI64Type(), i); - mlir::Value indexValue = rewriter.create( - loc, maskedIndices, iValue); + mlir::LLVM::ConstantOp::create(rewriter, loc, rewriter.getI64Type(), i); + mlir::Value indexValue = mlir::LLVM::ExtractElementOp::create( + rewriter, loc, maskedIndices, iValue); mlir::Value valueAtIndex = - rewriter.create(loc, input, indexValue); - result = rewriter.create(loc, result, - valueAtIndex, iValue); + mlir::LLVM::ExtractElementOp::create(rewriter, loc, input, indexValue); + result = mlir::LLVM::InsertElementOp::create(rewriter, loc, result, + valueAtIndex, iValue); } rewriter.replaceOp(op, result); return mlir::success(); @@ -2219,8 +2230,8 @@ mlir::LogicalResult CIRToLLVMVAStartOpLowering::matchAndRewrite( cir::VAStartOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto opaquePtr = mlir::LLVM::LLVMPointerType::get(getContext()); - auto vaList = rewriter.create(op.getLoc(), opaquePtr, - adaptor.getArgList()); + auto vaList = mlir::LLVM::BitcastOp::create(rewriter, op.getLoc(), opaquePtr, + adaptor.getArgList()); rewriter.replaceOpWithNewOp(op, vaList); return mlir::success(); } @@ -2229,8 +2240,8 @@ mlir::LogicalResult CIRToLLVMVAEndOpLowering::matchAndRewrite( cir::VAEndOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto opaquePtr = mlir::LLVM::LLVMPointerType::get(getContext()); - auto vaList = rewriter.create(op.getLoc(), opaquePtr, - adaptor.getArgList()); + auto vaList = mlir::LLVM::BitcastOp::create(rewriter, op.getLoc(), opaquePtr, + adaptor.getArgList()); rewriter.replaceOpWithNewOp(op, vaList); return mlir::success(); } @@ -2239,10 +2250,10 @@ mlir::LogicalResult CIRToLLVMVACopyOpLowering::matchAndRewrite( cir::VACopyOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto opaquePtr = mlir::LLVM::LLVMPointerType::get(getContext()); - auto dstList = rewriter.create(op.getLoc(), opaquePtr, - adaptor.getDstList()); - auto srcList = rewriter.create(op.getLoc(), opaquePtr, - adaptor.getSrcList()); + auto dstList = mlir::LLVM::BitcastOp::create(rewriter, op.getLoc(), opaquePtr, + adaptor.getDstList()); + auto srcList = mlir::LLVM::BitcastOp::create(rewriter, op.getLoc(), opaquePtr, + adaptor.getSrcList()); rewriter.replaceOpWithNewOp(op, dstList, srcList); return mlir::success(); } @@ -2340,8 +2351,8 @@ mlir::LogicalResult CIRToLLVMFuncOpLowering::matchAndRewriteAlias( assert(!cir::MissingFeatures::addressSpace()); mlir::Type ptrTy = mlir::LLVM::LLVMPointerType::get(ty.getContext()); auto addrOp = - builder.create(loc, ptrTy, aliasee.getValue()); - builder.create(loc, addrOp); + mlir::LLVM::AddressOfOp::create(builder, loc, ptrTy, aliasee.getValue()); + mlir::LLVM::ReturnOp::create(builder, loc, addrOp); return mlir::success(); } @@ -2391,9 +2402,9 @@ mlir::LogicalResult CIRToLLVMFuncOpLowering::matchAndRewrite( SmallVector attributes; lowerFuncAttributes(op, /*filterArgAndResAttrs=*/false, attributes); - auto fn = rewriter.create( - Loc, op.getName(), llvmFnTy, linkage, isDsoLocal, cconv, - mlir::SymbolRefAttr(), attributes); + auto fn = mlir::LLVM::LLVMFuncOp::create(rewriter, Loc, op.getName(), + llvmFnTy, linkage, isDsoLocal, cconv, + mlir::SymbolRefAttr(), attributes); // Lower CIR attributes for arguments. for (unsigned index = 0; index < fnType.getNumInputs(); index++) { @@ -2450,12 +2461,12 @@ mlir::LogicalResult CIRToLLVMGetGlobalOpLowering::matchAndRewrite( auto type = getTypeConverter()->convertType(op.getType()); auto symbol = op.getName(); mlir::Operation *newop = - rewriter.create(op.getLoc(), type, symbol); + mlir::LLVM::AddressOfOp::create(rewriter, op.getLoc(), type, symbol); if (op.getTls()) { // Handle access to TLS via intrinsic. - newop = rewriter.create( - op.getLoc(), type, newop->getResult(0)); + newop = mlir::LLVM::ThreadlocalAddressOp::create(rewriter, op.getLoc(), + type, newop->getResult(0)); } rewriter.replaceOp(op, newop); @@ -2467,15 +2478,15 @@ mlir::LogicalResult CIRToLLVMComplexCreateOpLowering::matchAndRewrite( mlir::ConversionPatternRewriter &rewriter) const { auto complexLLVMTy = getTypeConverter()->convertType(op.getType()); auto initialComplex = - rewriter.create(op->getLoc(), complexLLVMTy); + mlir::LLVM::UndefOp::create(rewriter, op->getLoc(), complexLLVMTy); int64_t position[1]{0}; - auto realComplex = rewriter.create( - op->getLoc(), initialComplex, adaptor.getReal(), position); + auto realComplex = mlir::LLVM::InsertValueOp::create( + rewriter, op->getLoc(), initialComplex, adaptor.getReal(), position); position[0] = 1; - auto complex = rewriter.create( - op->getLoc(), realComplex, adaptor.getImag(), position); + auto complex = mlir::LLVM::InsertValueOp::create( + rewriter, op->getLoc(), realComplex, adaptor.getImag(), position); rewriter.replaceOp(op, complex); return mlir::success(); @@ -2756,8 +2767,8 @@ mlir::LogicalResult CIRToLLVMGlobalOpLowering::matchAndRewrite( llvmGlobalOp.getInitializerRegion().push_back(new mlir::Block()); rewriter.setInsertionPointToEnd(llvmGlobalOp.getInitializerBlock()); - rewriter.create( - op->getLoc(), + mlir::LLVM::ReturnOp::create( + rewriter, op->getLoc(), lowerCirAttrAsValue(op, init, rewriter, typeConverter, dataLayout)); } @@ -2776,11 +2787,12 @@ void CIRToLLVMGlobalOpLowering::addComdat(mlir::LLVM::GlobalOp &op, if (!comdatOp) { builder.setInsertionPointToStart(module.getBody()); comdatOp = - builder.create(module.getLoc(), comdatName); + mlir::LLVM::ComdatOp::create(builder, module.getLoc(), comdatName); } builder.setInsertionPointToStart(&comdatOp.getBody().back()); - auto selectorOp = builder.create( - comdatOp.getLoc(), op.getSymName(), mlir::LLVM::comdat::Comdat::Any); + auto selectorOp = mlir::LLVM::ComdatSelectorOp::create( + builder, comdatOp.getLoc(), op.getSymName(), + mlir::LLVM::comdat::Comdat::Any); op.setComdatAttr(mlir::SymbolRefAttr::get( builder.getContext(), comdatName, mlir::FlatSymbolRefAttr::get(selectorOp.getSymNameAttr()))); @@ -2805,14 +2817,14 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite( switch (op.getKind()) { case cir::UnaryOpKind::Inc: { assert(!IsVector && "++ not allowed on vector types"); - auto One = rewriter.create(loc, llvmType, 1); + auto One = mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, 1); rewriter.replaceOpWithNewOp( op, llvmType, adaptor.getInput(), One, overflowFlags); return mlir::success(); } case cir::UnaryOpKind::Dec: { assert(!IsVector && "-- not allowed on vector types"); - auto One = rewriter.create(loc, llvmType, 1); + auto One = mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, 1); rewriter.replaceOpWithNewOp( op, llvmType, adaptor.getInput(), One, overflowFlags); return mlir::success(); @@ -2824,9 +2836,9 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite( case cir::UnaryOpKind::Minus: { mlir::Value Zero; if (IsVector) - Zero = rewriter.create(loc, llvmType); + Zero = mlir::LLVM::ZeroOp::create(rewriter, loc, llvmType); else - Zero = rewriter.create(loc, llvmType, 0); + Zero = mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, 0); rewriter.replaceOpWithNewOp( op, Zero, adaptor.getInput(), overflowFlags); return mlir::success(); @@ -2840,17 +2852,17 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite( mlir::Type llvmElementType = getTypeConverter()->convertType(elementType); auto MinusOneInt = - rewriter.create(loc, llvmElementType, -1); - minusOne = rewriter.create(loc, llvmType); + mlir::LLVM::ConstantOp::create(rewriter, loc, llvmElementType, -1); + minusOne = mlir::LLVM::UndefOp::create(rewriter, loc, llvmType); auto NumElements = mlir::dyn_cast(type).getSize(); for (uint64_t i = 0; i < NumElements; ++i) { - mlir::Value indexValue = rewriter.create( - loc, rewriter.getI64Type(), i); - minusOne = rewriter.create( - loc, minusOne, MinusOneInt, indexValue); + mlir::Value indexValue = mlir::LLVM::ConstantOp::create( + rewriter, loc, rewriter.getI64Type(), i); + minusOne = mlir::LLVM::InsertElementOp::create( + rewriter, loc, minusOne, MinusOneInt, indexValue); } } else { - minusOne = rewriter.create(loc, llvmType, -1); + minusOne = mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, -1); } rewriter.replaceOpWithNewOp(op, adaptor.getInput(), minusOne); @@ -2866,7 +2878,7 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite( assert(!IsVector && "++ not allowed on vector types"); auto oneAttr = rewriter.getFloatAttr(llvmType, 1.0); auto oneConst = - rewriter.create(loc, llvmType, oneAttr); + mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, oneAttr); rewriter.replaceOpWithNewOp(op, llvmType, oneConst, adaptor.getInput()); return mlir::success(); @@ -2875,7 +2887,7 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite( assert(!IsVector && "-- not allowed on vector types"); auto negOneAttr = rewriter.getFloatAttr(llvmType, -1.0); auto negOneConst = - rewriter.create(loc, llvmType, negOneAttr); + mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, negOneAttr); rewriter.replaceOpWithNewOp(op, llvmType, negOneConst, adaptor.getInput()); return mlir::success(); @@ -2902,7 +2914,7 @@ mlir::LogicalResult CIRToLLVMUnaryOpLowering::matchAndRewrite( assert(!IsVector && "NYI: op! on vector mask"); rewriter.replaceOpWithNewOp( op, adaptor.getInput(), - rewriter.create(loc, llvmType, 1)); + mlir::LLVM::ConstantOp::create(rewriter, loc, llvmType, 1)); return mlir::success(); default: return op.emitError() @@ -3059,11 +3071,11 @@ mlir::LogicalResult CIRToLLVMBinOpOverflowOpLowering::matchAndRewrite( auto rhs = adaptor.getRhs(); if (operandTy.getWidth() < encompassedTyInfo.width) { if (operandTy.isSigned()) { - lhs = rewriter.create(loc, encompassedLLVMTy, lhs); - rhs = rewriter.create(loc, encompassedLLVMTy, rhs); + lhs = mlir::LLVM::SExtOp::create(rewriter, loc, encompassedLLVMTy, lhs); + rhs = mlir::LLVM::SExtOp::create(rewriter, loc, encompassedLLVMTy, rhs); } else { - lhs = rewriter.create(loc, encompassedLLVMTy, lhs); - rhs = rewriter.create(loc, encompassedLLVMTy, rhs); + lhs = mlir::LLVM::ZExtOp::create(rewriter, loc, encompassedLLVMTy, lhs); + rhs = mlir::LLVM::ZExtOp::create(rewriter, loc, encompassedLLVMTy, rhs); } } @@ -3075,43 +3087,41 @@ mlir::LogicalResult CIRToLLVMBinOpOverflowOpLowering::matchAndRewrite( auto intrinRetTy = mlir::LLVM::LLVMStructType::getLiteral( rewriter.getContext(), {encompassedLLVMTy, overflowLLVMTy}); - auto callLLVMIntrinOp = rewriter.create( - loc, intrinRetTy, intrinNameAttr, mlir::ValueRange{lhs, rhs}); + auto callLLVMIntrinOp = mlir::LLVM::CallIntrinsicOp::create( + rewriter, loc, intrinRetTy, intrinNameAttr, mlir::ValueRange{lhs, rhs}); auto intrinRet = callLLVMIntrinOp.getResult(0); - auto result = rewriter - .create(loc, intrinRet, - ArrayRef{0}) + auto result = mlir::LLVM::ExtractValueOp::create(rewriter, loc, intrinRet, + ArrayRef{0}) .getResult(); - auto overflow = rewriter - .create(loc, intrinRet, - ArrayRef{1}) + auto overflow = mlir::LLVM::ExtractValueOp::create(rewriter, loc, intrinRet, + ArrayRef{1}) .getResult(); if (resultTy.getWidth() < encompassedTyInfo.width) { auto resultLLVMTy = getTypeConverter()->convertType(resultTy); auto truncResult = - rewriter.create(loc, resultLLVMTy, result); + mlir::LLVM::TruncOp::create(rewriter, loc, resultLLVMTy, result); // Extend the truncated result back to the encompassing type to check for // any overflows during the truncation. mlir::Value truncResultExt; if (resultTy.isSigned()) - truncResultExt = rewriter.create( - loc, encompassedLLVMTy, truncResult); + truncResultExt = mlir::LLVM::SExtOp::create( + rewriter, loc, encompassedLLVMTy, truncResult); else - truncResultExt = rewriter.create( - loc, encompassedLLVMTy, truncResult); - auto truncOverflow = rewriter.create( - loc, mlir::LLVM::ICmpPredicate::ne, truncResultExt, result); + truncResultExt = mlir::LLVM::ZExtOp::create( + rewriter, loc, encompassedLLVMTy, truncResult); + auto truncOverflow = mlir::LLVM::ICmpOp::create( + rewriter, loc, mlir::LLVM::ICmpPredicate::ne, truncResultExt, result); result = truncResult; - overflow = rewriter.create(loc, overflow, truncOverflow); + overflow = mlir::LLVM::OrOp::create(rewriter, loc, overflow, truncOverflow); } auto boolLLVMTy = getTypeConverter()->convertType(op.getOverflow().getType()); if (boolLLVMTy != rewriter.getI1Type()) - overflow = rewriter.create(loc, boolLLVMTy, overflow); + overflow = mlir::LLVM::ZExtOp::create(rewriter, loc, boolLLVMTy, overflow); rewriter.replaceOp(op, mlir::ValueRange{result, overflow}); @@ -3259,8 +3269,8 @@ createCallLLVMIntrinsicOp(mlir::ConversionPatternRewriter &rewriter, mlir::Type resultTy, mlir::ValueRange operands) { auto intrinsicNameAttr = mlir::StringAttr::get(rewriter.getContext(), intrinsicName); - return rewriter.create( - loc, resultTy, intrinsicNameAttr, operands); + return mlir::LLVM::CallIntrinsicOp::create(rewriter, loc, resultTy, + intrinsicNameAttr, operands); } mlir::LLVM::CallIntrinsicOp replaceOpWithCallLLVMIntrinsicOp( @@ -3309,17 +3319,17 @@ mlir::LogicalResult CIRToLLVMAssumeAlignedOpLowering::matchAndRewrite( mlir::ConversionPatternRewriter &rewriter) const { SmallVector opBundleArgs{adaptor.getPointer()}; - auto alignment = rewriter.create( - op.getLoc(), rewriter.getI64Type(), op.getAlignment()); + auto alignment = mlir::LLVM::ConstantOp::create( + rewriter, op.getLoc(), rewriter.getI64Type(), op.getAlignment()); opBundleArgs.push_back(alignment); if (mlir::Value offset = adaptor.getOffset()) opBundleArgs.push_back(offset); - auto cond = rewriter.create(op.getLoc(), - rewriter.getI1Type(), 1); - rewriter.create(op.getLoc(), cond, "align", - opBundleArgs); + auto cond = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), + rewriter.getI1Type(), 1); + mlir::LLVM::AssumeOp::create(rewriter, op.getLoc(), cond, "align", + opBundleArgs); rewriter.replaceAllUsesWith(op, op.getPointer()); rewriter.eraseOp(op); @@ -3329,8 +3339,8 @@ mlir::LogicalResult CIRToLLVMAssumeAlignedOpLowering::matchAndRewrite( mlir::LogicalResult CIRToLLVMAssumeSepStorageOpLowering::matchAndRewrite( cir::AssumeSepStorageOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - auto cond = rewriter.create(op.getLoc(), - rewriter.getI1Type(), 1); + auto cond = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), + rewriter.getI1Type(), 1); rewriter.replaceOpWithNewOp( op, cond, "separate_storage", mlir::ValueRange{adaptor.getPtr1(), adaptor.getPtr2()}); @@ -3340,28 +3350,28 @@ mlir::LogicalResult CIRToLLVMAssumeSepStorageOpLowering::matchAndRewrite( mlir::LogicalResult CIRToLLVMBitClrsbOpLowering::matchAndRewrite( cir::BitClrsbOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - auto zero = rewriter.create( - op.getLoc(), adaptor.getInput().getType(), 0); - auto isNeg = rewriter.create( - op.getLoc(), + auto zero = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), + adaptor.getInput().getType(), 0); + auto isNeg = mlir::LLVM::ICmpOp::create( + rewriter, op.getLoc(), mlir::LLVM::ICmpPredicateAttr::get(rewriter.getContext(), mlir::LLVM::ICmpPredicate::slt), adaptor.getInput(), zero); - auto negOne = rewriter.create( - op.getLoc(), adaptor.getInput().getType(), -1); - auto flipped = rewriter.create(op.getLoc(), - adaptor.getInput(), negOne); + auto negOne = mlir::LLVM::ConstantOp::create( + rewriter, op.getLoc(), adaptor.getInput().getType(), -1); + auto flipped = mlir::LLVM::XOrOp::create(rewriter, op.getLoc(), + adaptor.getInput(), negOne); - auto select = rewriter.create( - op.getLoc(), isNeg, flipped, adaptor.getInput()); + auto select = mlir::LLVM::SelectOp::create(rewriter, op.getLoc(), isNeg, + flipped, adaptor.getInput()); auto resTy = getTypeConverter()->convertType(op.getType()); - auto clz = rewriter.create( - op.getLoc(), resTy, select, false); + auto clz = mlir::LLVM::CountLeadingZerosOp::create(rewriter, op.getLoc(), + resTy, select, false); - auto one = rewriter.create(op.getLoc(), resTy, 1); - auto res = rewriter.create(op.getLoc(), clz, one); + auto one = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), resTy, 1); + auto res = mlir::LLVM::SubOp::create(rewriter, op.getLoc(), clz, one); rewriter.replaceOp(op, res); return mlir::LogicalResult::success(); @@ -3395,8 +3405,8 @@ mlir::LogicalResult CIRToLLVMBitClzOpLowering::matchAndRewrite( cir::BitClzOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto resTy = getTypeConverter()->convertType(op.getType()); - auto llvmOp = rewriter.create( - op.getLoc(), resTy, adaptor.getInput(), op.getIsZeroPoison()); + auto llvmOp = mlir::LLVM::CountLeadingZerosOp::create( + rewriter, op.getLoc(), resTy, adaptor.getInput(), op.getIsZeroPoison()); rewriter.replaceOp(op, llvmOp); return mlir::LogicalResult::success(); } @@ -3405,8 +3415,8 @@ mlir::LogicalResult CIRToLLVMBitCtzOpLowering::matchAndRewrite( cir::BitCtzOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto resTy = getTypeConverter()->convertType(op.getType()); - auto llvmOp = rewriter.create( - op.getLoc(), resTy, adaptor.getInput(), op.getIsZeroPoison()); + auto llvmOp = mlir::LLVM::CountTrailingZerosOp::create( + rewriter, op.getLoc(), resTy, adaptor.getInput(), op.getIsZeroPoison()); rewriter.replaceOp(op, llvmOp); return mlir::LogicalResult::success(); } @@ -3415,23 +3425,23 @@ mlir::LogicalResult CIRToLLVMBitFfsOpLowering::matchAndRewrite( cir::BitFfsOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto resTy = getTypeConverter()->convertType(op.getType()); - auto ctz = rewriter.create( - op.getLoc(), resTy, adaptor.getInput(), false); + auto ctz = mlir::LLVM::CountTrailingZerosOp::create( + rewriter, op.getLoc(), resTy, adaptor.getInput(), false); - auto one = rewriter.create(op.getLoc(), resTy, 1); - auto ctzAddOne = rewriter.create(op.getLoc(), ctz, one); + auto one = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), resTy, 1); + auto ctzAddOne = mlir::LLVM::AddOp::create(rewriter, op.getLoc(), ctz, one); - auto zeroInputTy = rewriter.create( - op.getLoc(), adaptor.getInput().getType(), 0); - auto isZero = rewriter.create( - op.getLoc(), + auto zeroInputTy = mlir::LLVM::ConstantOp::create( + rewriter, op.getLoc(), adaptor.getInput().getType(), 0); + auto isZero = mlir::LLVM::ICmpOp::create( + rewriter, op.getLoc(), mlir::LLVM::ICmpPredicateAttr::get(rewriter.getContext(), mlir::LLVM::ICmpPredicate::eq), adaptor.getInput(), zeroInputTy); - auto zero = rewriter.create(op.getLoc(), resTy, 0); - auto res = rewriter.create(op.getLoc(), isZero, zero, - ctzAddOne); + auto zero = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), resTy, 0); + auto res = mlir::LLVM::SelectOp::create(rewriter, op.getLoc(), isZero, zero, + ctzAddOne); rewriter.replaceOp(op, res); return mlir::LogicalResult::success(); @@ -3441,12 +3451,12 @@ mlir::LogicalResult CIRToLLVMBitParityOpLowering::matchAndRewrite( cir::BitParityOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto resTy = getTypeConverter()->convertType(op.getType()); - auto popcnt = rewriter.create(op.getLoc(), resTy, - adaptor.getInput()); + auto popcnt = mlir::LLVM::CtPopOp::create(rewriter, op.getLoc(), resTy, + adaptor.getInput()); - auto one = rewriter.create(op.getLoc(), resTy, 1); + auto one = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), resTy, 1); auto popcntMod2 = - rewriter.create(op.getLoc(), popcnt, one); + mlir::LLVM::AndOp::create(rewriter, op.getLoc(), popcnt, one); rewriter.replaceOp(op, popcntMod2); return mlir::LogicalResult::success(); @@ -3456,8 +3466,8 @@ mlir::LogicalResult CIRToLLVMBitPopcountOpLowering::matchAndRewrite( cir::BitPopcountOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto resTy = getTypeConverter()->convertType(op.getType()); - auto llvmOp = rewriter.create(op.getLoc(), resTy, - adaptor.getInput()); + auto llvmOp = mlir::LLVM::CtPopOp::create(rewriter, op.getLoc(), resTy, + adaptor.getInput()); rewriter.replaceOp(op, llvmOp); return mlir::LogicalResult::success(); } @@ -3485,8 +3495,8 @@ mlir::LogicalResult CIRToLLVMAtomicCmpXchgLowering::matchAndRewrite( auto expected = adaptor.getExpected(); auto desired = adaptor.getDesired(); - auto cmpxchg = rewriter.create( - op.getLoc(), adaptor.getPtr(), expected, desired, + auto cmpxchg = mlir::LLVM::AtomicCmpXchgOp::create( + rewriter, op.getLoc(), adaptor.getPtr(), expected, desired, getLLVMAtomicOrder(adaptor.getSuccOrder()), getLLVMAtomicOrder(adaptor.getFailOrder())); cmpxchg.setSyncscope(getLLVMSyncScope(adaptor.getSyncscope())); @@ -3495,10 +3505,10 @@ mlir::LogicalResult CIRToLLVMAtomicCmpXchgLowering::matchAndRewrite( cmpxchg.setVolatile_(adaptor.getIsVolatile()); // Check result and apply stores accordingly. - auto old = rewriter.create( - op.getLoc(), cmpxchg.getResult(), 0); - auto cmp = rewriter.create( - op.getLoc(), cmpxchg.getResult(), 1); + auto old = mlir::LLVM::ExtractValueOp::create(rewriter, op.getLoc(), + cmpxchg.getResult(), 0); + auto cmp = mlir::LLVM::ExtractValueOp::create(rewriter, op.getLoc(), + cmpxchg.getResult(), 1); rewriter.replaceOp(op, {old, cmp}); return mlir::success(); @@ -3542,11 +3552,12 @@ mlir::Value CIRToLLVMAtomicFetchLowering::buildMinMaxPostOp( : mlir::LLVM::ICmpPredicate::ult; } - auto cmp = rewriter.create( - loc, mlir::LLVM::ICmpPredicateAttr::get(rewriter.getContext(), pred), - rmwVal, adaptor.getVal()); - return rewriter.create(loc, cmp, rmwVal, - adaptor.getVal()); + auto cmp = mlir::LLVM::ICmpOp::create( + rewriter, loc, + mlir::LLVM::ICmpPredicateAttr::get(rewriter.getContext(), pred), rmwVal, + adaptor.getVal()); + return mlir::LLVM::SelectOp::create(rewriter, loc, cmp, rmwVal, + adaptor.getVal()); } llvm::StringLiteral @@ -3623,8 +3634,9 @@ mlir::LogicalResult CIRToLLVMAtomicFetchLowering::matchAndRewrite( // FIXME: add syncscope. auto llvmOrder = getLLVMAtomicOrder(adaptor.getMemOrder()); auto llvmBinOpc = getLLVMAtomicBinOp(op.getBinop(), isInt, isSignedInt); - auto rmwVal = rewriter.create( - op.getLoc(), llvmBinOpc, adaptor.getPtr(), adaptor.getVal(), llvmOrder); + auto rmwVal = mlir::LLVM::AtomicRMWOp::create(rewriter, op.getLoc(), + llvmBinOpc, adaptor.getPtr(), + adaptor.getVal(), llvmOrder); mlir::Value result = rmwVal.getRes(); if (!op.getFetchFirst()) { @@ -3637,9 +3649,9 @@ mlir::LogicalResult CIRToLLVMAtomicFetchLowering::matchAndRewrite( // Compensate lack of nand binop in LLVM IR. if (op.getBinop() == cir::AtomicFetchKind::Nand) { - auto negOne = rewriter.create( - op.getLoc(), result.getType(), -1); - result = rewriter.create(op.getLoc(), result, negOne); + auto negOne = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), + result.getType(), -1); + result = mlir::LLVM::XOrOp::create(rewriter, op.getLoc(), result, negOne); } } @@ -3687,7 +3699,7 @@ mlir::LogicalResult CIRToLLVMAtomicFenceLowering::matchAndRewrite( mlir::ConversionPatternRewriter &rewriter) const { auto llvmOrder = getLLVMAtomicOrder(adaptor.getOrdering()); - auto fence = rewriter.create(op.getLoc(), llvmOrder); + auto fence = mlir::LLVM::FenceOp::create(rewriter, op.getLoc(), llvmOrder); fence.setSyncscope(getLLVMSyncScope(adaptor.getSyncscope())); rewriter.replaceOp(op, fence); @@ -3891,13 +3903,13 @@ mlir::LogicalResult CIRToLLVMPtrDiffOpLowering::matchAndRewrite( auto dstTy = mlir::cast(op.getType()); auto llvmDstTy = getTypeConverter()->convertType(dstTy); - auto lhs = rewriter.create(op.getLoc(), llvmDstTy, - adaptor.getLhs()); - auto rhs = rewriter.create(op.getLoc(), llvmDstTy, - adaptor.getRhs()); + auto lhs = mlir::LLVM::PtrToIntOp::create(rewriter, op.getLoc(), llvmDstTy, + adaptor.getLhs()); + auto rhs = mlir::LLVM::PtrToIntOp::create(rewriter, op.getLoc(), llvmDstTy, + adaptor.getRhs()); auto diff = - rewriter.create(op.getLoc(), llvmDstTy, lhs, rhs); + mlir::LLVM::SubOp::create(rewriter, op.getLoc(), llvmDstTy, lhs, rhs); cir::PointerType ptrTy = op.getLhs().getType(); auto typeSize = getTypeSize(ptrTy.getPointee(), *op); @@ -3905,15 +3917,15 @@ mlir::LogicalResult CIRToLLVMPtrDiffOpLowering::matchAndRewrite( // Avoid silly division by 1. auto resultVal = diff.getResult(); if (typeSize != 1) { - auto typeSizeVal = rewriter.create( - op.getLoc(), llvmDstTy, typeSize); + auto typeSizeVal = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), + llvmDstTy, typeSize); if (dstTy.isUnsigned()) resultVal = - rewriter.create(op.getLoc(), diff, typeSizeVal); + mlir::LLVM::UDivOp::create(rewriter, op.getLoc(), diff, typeSizeVal); else resultVal = - rewriter.create(op.getLoc(), diff, typeSizeVal); + mlir::LLVM::SDivOp::create(rewriter, op.getLoc(), diff, typeSizeVal); } rewriter.replaceOp(op, resultVal); return mlir::success(); @@ -4004,12 +4016,12 @@ mlir::LogicalResult CIRToLLVMTrapOpLowering::matchAndRewrite( auto loc = op->getLoc(); rewriter.eraseOp(op); - rewriter.create(loc); + mlir::LLVM::Trap::create(rewriter, loc); // Note that the call to llvm.trap is not a terminator in LLVM dialect. // So we must emit an additional llvm.unreachable to terminate the current // block. - rewriter.create(loc); + mlir::LLVM::UnreachableOp::create(rewriter, loc); return mlir::success(); } @@ -4129,8 +4141,8 @@ mlir::LogicalResult CIRToLLVMSetBitfieldOpLowering::matchAndRewrite( if (storageSize != size) { assert(storageSize > size && "Invalid bitfield size."); - mlir::Value val = rewriter.create( - op.getLoc(), intType, adaptor.getAddr(), op.getAlignment(), + mlir::Value val = mlir::LLVM::LoadOp::create( + rewriter, op.getLoc(), intType, adaptor.getAddr(), op.getAlignment(), op.getIsVolatile()); srcVal = @@ -4143,11 +4155,11 @@ mlir::LogicalResult CIRToLLVMSetBitfieldOpLowering::matchAndRewrite( ~llvm::APInt::getBitsSet(srcWidth, offset, offset + size)); // Or together the unchanged values and the source value. - srcVal = rewriter.create(op.getLoc(), val, srcVal); + srcVal = mlir::LLVM::OrOp::create(rewriter, op.getLoc(), val, srcVal); } - rewriter.create(op.getLoc(), srcVal, adaptor.getAddr(), - op.getAlignment(), op.getIsVolatile()); + mlir::LLVM::StoreOp::create(rewriter, op.getLoc(), srcVal, adaptor.getAddr(), + op.getAlignment(), op.getIsVolatile()); auto resultTy = getTypeConverter()->convertType(op.getType()); @@ -4193,10 +4205,10 @@ mlir::LogicalResult CIRToLLVMGetBitfieldOpLowering::matchAndRewrite( auto intType = mlir::IntegerType::get(context, storageSize); - mlir::Value val = rewriter.create( - op.getLoc(), intType, adaptor.getAddr(), op.getAlignment(), + mlir::Value val = mlir::LLVM::LoadOp::create( + rewriter, op.getLoc(), intType, adaptor.getAddr(), op.getAlignment(), op.getIsVolatile()); - val = rewriter.create(op.getLoc(), intType, val); + val = mlir::LLVM::BitcastOp::create(rewriter, op.getLoc(), intType, val); if (info.getIsSigned()) { assert(static_cast(offset + size) <= storageSize); @@ -4332,8 +4344,9 @@ mlir::LogicalResult CIRToLLVMClearCacheOpLowering::matchAndRewrite( mlir::LogicalResult CIRToLLVMEhTypeIdOpLowering::matchAndRewrite( cir::EhTypeIdOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - mlir::Value addrOp = rewriter.create( - op.getLoc(), mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), + mlir::Value addrOp = mlir::LLVM::AddressOfOp::create( + rewriter, op.getLoc(), + mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), op.getTypeSymAttr()); mlir::LLVM::CallIntrinsicOp newOp = createCallLLVMIntrinsicOp( rewriter, op.getLoc(), "llvm.eh.typeid.for.p0", rewriter.getI32Type(), @@ -4392,8 +4405,8 @@ mlir::LogicalResult CIRToLLVMCatchParamOpLowering::matchAndRewrite( mlir::LLVM::LLVMVoidType::get(rewriter.getContext()), {}, /*isVarArg=*/false); getOrCreateLLVMFuncOp(rewriter, op, fnName, fnTy); - rewriter.create(op.getLoc(), mlir::TypeRange{}, fnName, - mlir::ValueRange{}); + mlir::LLVM::CallOp::create(rewriter, op.getLoc(), mlir::TypeRange{}, fnName, + mlir::ValueRange{}); rewriter.eraseOp(op); return mlir::success(); } @@ -4410,13 +4423,13 @@ mlir::LogicalResult CIRToLLVMResumeOpLowering::matchAndRewrite( SmallVector slotIdx = {0}; SmallVector selectorIdx = {1}; auto llvmLandingPadStructTy = getLLVMLandingPadStructTy(rewriter); - mlir::Value poison = rewriter.create( - op.getLoc(), llvmLandingPadStructTy); + mlir::Value poison = mlir::LLVM::PoisonOp::create(rewriter, op.getLoc(), + llvmLandingPadStructTy); - mlir::Value slot = rewriter.create( - op.getLoc(), poison, adaptor.getExceptionPtr(), slotIdx); - mlir::Value selector = rewriter.create( - op.getLoc(), slot, adaptor.getTypeId(), selectorIdx); + mlir::Value slot = mlir::LLVM::InsertValueOp::create( + rewriter, op.getLoc(), poison, adaptor.getExceptionPtr(), slotIdx); + mlir::Value selector = mlir::LLVM::InsertValueOp::create( + rewriter, op.getLoc(), slot, adaptor.getTypeId(), selectorIdx); rewriter.replaceOpWithNewOp(op, selector); return mlir::success(); @@ -4432,8 +4445,8 @@ mlir::LogicalResult CIRToLLVMAllocExceptionOpLowering::matchAndRewrite( auto fnTy = mlir::LLVM::LLVMFunctionType::get(llvmPtrTy, {int64Ty}, /*isVarArg=*/false); getOrCreateLLVMFuncOp(rewriter, op, fnName, fnTy); - auto size = rewriter.create(op.getLoc(), - adaptor.getSizeAttr()); + auto size = mlir::LLVM::ConstantOp::create(rewriter, op.getLoc(), + adaptor.getSizeAttr()); rewriter.replaceOpWithNewOp( op, mlir::TypeRange{llvmPtrTy}, fnName, mlir::ValueRange{size}); return mlir::success(); @@ -4465,18 +4478,21 @@ mlir::LogicalResult CIRToLLVMThrowOpLowering::matchAndRewrite( voidTy, {llvmPtrTy, llvmPtrTy, llvmPtrTy}, /*isVarArg=*/false); getOrCreateLLVMFuncOp(rewriter, op, fnName, fnTy); - mlir::Value typeInfo = rewriter.create( - op.getLoc(), mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), + mlir::Value typeInfo = mlir::LLVM::AddressOfOp::create( + rewriter, op.getLoc(), + mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), adaptor.getTypeInfoAttr()); mlir::Value dtor; if (op.getDtor()) { - dtor = rewriter.create( - op.getLoc(), mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), + dtor = mlir::LLVM::AddressOfOp::create( + rewriter, op.getLoc(), + mlir::LLVM::LLVMPointerType::get(rewriter.getContext()), adaptor.getDtorAttr()); } else { - dtor = rewriter.create( - op.getLoc(), mlir::LLVM::LLVMPointerType::get(rewriter.getContext())); + dtor = mlir::LLVM::ZeroOp::create( + rewriter, op.getLoc(), + mlir::LLVM::LLVMPointerType::get(rewriter.getContext())); } rewriter.replaceOpWithNewOp( op, mlir::TypeRange{}, fnName, @@ -4499,8 +4515,9 @@ mlir::LogicalResult CIRToLLVMAbsOpLowering::matchAndRewrite( cir::AbsOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { auto resTy = this->getTypeConverter()->convertType(op.getType()); - auto absOp = rewriter.create( - op.getLoc(), resTy, adaptor.getOperands()[0], adaptor.getPoison()); + auto absOp = + mlir::LLVM::AbsOp::create(rewriter, op.getLoc(), resTy, + adaptor.getOperands()[0], adaptor.getPoison()); rewriter.replaceOp(op, absOp); return mlir::success(); } @@ -4523,11 +4540,12 @@ mlir::LogicalResult CIRToLLVMSignBitOpLowering::matchAndRewrite( } } auto intTy = mlir::IntegerType::get(rewriter.getContext(), width); - auto bitcast = rewriter.create(op->getLoc(), intTy, - adaptor.getInput()); - auto zero = rewriter.create(op->getLoc(), intTy, 0); - auto cmpResult = rewriter.create( - op.getLoc(), mlir::LLVM::ICmpPredicate::slt, bitcast.getResult(), zero); + auto bitcast = mlir::LLVM::BitcastOp::create(rewriter, op->getLoc(), intTy, + adaptor.getInput()); + auto zero = mlir::LLVM::ConstantOp::create(rewriter, op->getLoc(), intTy, 0); + auto cmpResult = mlir::LLVM::ICmpOp::create(rewriter, op.getLoc(), + mlir::LLVM::ICmpPredicate::slt, + bitcast.getResult(), zero); rewriter.replaceOp(op, cmpResult); return mlir::success(); } @@ -4535,8 +4553,8 @@ mlir::LogicalResult CIRToLLVMSignBitOpLowering::matchAndRewrite( mlir::LogicalResult CIRToLLVMLinkerOptionsOpLowering::matchAndRewrite( cir::LinkerOptionsOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { - auto newOp = rewriter.create( - op.getLoc(), op.getOptionsAttr()); + auto newOp = mlir::LLVM::LinkerOptionsOp::create(rewriter, op.getLoc(), + op.getOptionsAttr()); rewriter.replaceOp(op, newOp); return mlir::success(); } @@ -4957,38 +4975,38 @@ void buildCtorDtorList( mlir::LLVM::LLVMArrayType::get(CtorStructTy, globalXtors.size()); auto loc = module.getLoc(); - auto newGlobalOp = builder.create( - loc, CtorStructArrayTy, true, mlir::LLVM::Linkage::Appending, + auto newGlobalOp = mlir::LLVM::GlobalOp::create( + builder, loc, CtorStructArrayTy, true, mlir::LLVM::Linkage::Appending, llvmXtorName, mlir::Attribute()); newGlobalOp.getRegion().push_back(new mlir::Block()); builder.setInsertionPointToEnd(newGlobalOp.getInitializerBlock()); mlir::Value result = - builder.create(loc, CtorStructArrayTy); + mlir::LLVM::UndefOp::create(builder, loc, CtorStructArrayTy); for (uint64_t I = 0; I < globalXtors.size(); I++) { auto fn = globalXtors[I]; mlir::Value structInit = - builder.create(loc, CtorStructTy); - mlir::Value initPriority = builder.create( - loc, CtorStructFields[0], fn.second); - mlir::Value initFuncAddr = builder.create( - loc, CtorStructFields[1], fn.first); + mlir::LLVM::UndefOp::create(builder, loc, CtorStructTy); + mlir::Value initPriority = mlir::LLVM::ConstantOp::create( + builder, loc, CtorStructFields[0], fn.second); + mlir::Value initFuncAddr = mlir::LLVM::AddressOfOp::create( + builder, loc, CtorStructFields[1], fn.first); mlir::Value initAssociate = - builder.create(loc, CtorStructFields[2]); - structInit = builder.create(loc, structInit, - initPriority, 0); - structInit = builder.create(loc, structInit, - initFuncAddr, 1); + mlir::LLVM::ZeroOp::create(builder, loc, CtorStructFields[2]); + structInit = mlir::LLVM::InsertValueOp::create( + builder, loc, structInit, initPriority, llvm::ArrayRef{0}); + structInit = mlir::LLVM::InsertValueOp::create(builder, loc, structInit, + initFuncAddr, 1); // TODO: handle associated data for initializers. - structInit = builder.create(loc, structInit, - initAssociate, 2); + structInit = mlir::LLVM::InsertValueOp::create(builder, loc, structInit, + initAssociate, 2); result = - builder.create(loc, result, structInit, I); + mlir::LLVM::InsertValueOp::create(builder, loc, result, structInit, I); } - builder.create(loc, result); + mlir::LLVM::ReturnOp::create(builder, loc, result); } // The unreachable code is not lowered by applyPartialConversion function @@ -5085,9 +5103,10 @@ void ConvertCIRToLLVMPass::buildGlobalAnnotationsVar( mlir::LLVM::LLVMArrayType::get(annoStructTy, annotationValuesArray.size()); mlir::Location moduleLoc = module.getLoc(); - auto annotationGlobalOp = globalVarBuilder.create( - moduleLoc, annoStructArrayTy, false, mlir::LLVM::Linkage::Appending, - "llvm.global.annotations", mlir::Attribute()); + auto annotationGlobalOp = mlir::LLVM::GlobalOp::create( + globalVarBuilder, moduleLoc, annoStructArrayTy, false, + mlir::LLVM::Linkage::Appending, "llvm.global.annotations", + mlir::Attribute()); annotationGlobalOp.setSection(llvmMetadataSectionName); annotationGlobalOp.getRegion().push_back(new mlir::Block()); mlir::OpBuilder varInitBuilder(module.getContext()); @@ -5098,22 +5117,22 @@ void ConvertCIRToLLVMPass::buildGlobalAnnotationsVar( // This is consistent with clang code gen. globalVarBuilder.setInsertionPoint(annotationGlobalOp); - mlir::Value result = varInitBuilder.create( - moduleLoc, annoStructArrayTy); + mlir::Value result = mlir::LLVM::UndefOp::create(varInitBuilder, moduleLoc, + annoStructArrayTy); int idx = 0; for (mlir::Attribute entry : annotationValuesArray) { auto annotValue = cast(entry); mlir::Value valueEntry = - varInitBuilder.create(moduleLoc, annoStructTy); + mlir::LLVM::UndefOp::create(varInitBuilder, moduleLoc, annoStructTy); SmallVector vals; auto globalValueName = mlir::cast(annotValue[0]); mlir::Operation *globalValue = mlir::SymbolTable::lookupSymbolIn(module, globalValueName); // The first field is ptr to the global value - auto globalValueFld = varInitBuilder.create( - moduleLoc, annoPtrTy, globalValueName); + auto globalValueFld = mlir::LLVM::AddressOfOp::create( + varInitBuilder, moduleLoc, annoPtrTy, globalValueName); vals.push_back(globalValueFld->getResult(0)); cir::AnnotationAttr annot = @@ -5123,13 +5142,13 @@ void ConvertCIRToLLVMPass::buildGlobalAnnotationsVar( argStringGlobalsMap, argsVarMap, vals); for (unsigned valIdx = 0, endIdx = vals.size(); valIdx != endIdx; ++valIdx) { - valueEntry = varInitBuilder.create( - moduleLoc, valueEntry, vals[valIdx], valIdx); + valueEntry = mlir::LLVM::InsertValueOp::create( + varInitBuilder, moduleLoc, valueEntry, vals[valIdx], valIdx); } - result = varInitBuilder.create( - moduleLoc, result, valueEntry, idx++); + result = mlir::LLVM::InsertValueOp::create(varInitBuilder, moduleLoc, + result, valueEntry, idx++); } - varInitBuilder.create(moduleLoc, result); + mlir::LLVM::ReturnOp::create(varInitBuilder, moduleLoc, result); } } diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LoweringHelpers.h b/clang/lib/CIR/Lowering/DirectToLLVM/LoweringHelpers.h index 0bf68b47189c..13bfa9d2315e 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LoweringHelpers.h +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LoweringHelpers.h @@ -23,50 +23,50 @@ mlir::Value createIntCast(mlir::OpBuilder &bld, mlir::Value src, auto loc = src.getLoc(); if (dstWidth > srcWidth && isSigned) - return bld.create(loc, dstTy, src); + return mlir::LLVM::SExtOp::create(bld, loc, dstTy, src); else if (dstWidth > srcWidth) - return bld.create(loc, dstTy, src); + return mlir::LLVM::ZExtOp::create(bld, loc, dstTy, src); else if (dstWidth < srcWidth) - return bld.create(loc, dstTy, src); + return mlir::LLVM::TruncOp::create(bld, loc, dstTy, src); else - return bld.create(loc, dstTy, src); + return mlir::LLVM::BitcastOp::create(bld, loc, dstTy, src); } mlir::Value getConstAPInt(mlir::OpBuilder &bld, mlir::Location loc, mlir::Type typ, const llvm::APInt &val) { - return bld.create(loc, typ, val); + return mlir::LLVM::ConstantOp::create(bld, loc, typ, val); } mlir::Value getConst(mlir::OpBuilder &bld, mlir::Location loc, mlir::Type typ, unsigned val) { - return bld.create(loc, typ, val); + return mlir::LLVM::ConstantOp::create(bld, loc, typ, val); } mlir::Value createShL(mlir::OpBuilder &bld, mlir::Value lhs, unsigned rhs) { if (!rhs) return lhs; auto rhsVal = getConst(bld, lhs.getLoc(), lhs.getType(), rhs); - return bld.create(lhs.getLoc(), lhs, rhsVal); + return mlir::LLVM::ShlOp::create(bld, lhs.getLoc(), lhs, rhsVal); } mlir::Value createLShR(mlir::OpBuilder &bld, mlir::Value lhs, unsigned rhs) { if (!rhs) return lhs; auto rhsVal = getConst(bld, lhs.getLoc(), lhs.getType(), rhs); - return bld.create(lhs.getLoc(), lhs, rhsVal); + return mlir::LLVM::LShrOp::create(bld, lhs.getLoc(), lhs, rhsVal); } mlir::Value createAShR(mlir::OpBuilder &bld, mlir::Value lhs, unsigned rhs) { if (!rhs) return lhs; auto rhsVal = getConst(bld, lhs.getLoc(), lhs.getType(), rhs); - return bld.create(lhs.getLoc(), lhs, rhsVal); + return mlir::LLVM::AShrOp::create(bld, lhs.getLoc(), lhs, rhsVal); } mlir::Value createAnd(mlir::OpBuilder &bld, mlir::Value lhs, const llvm::APInt &rhs) { auto rhsVal = getConstAPInt(bld, lhs.getLoc(), lhs.getType(), rhs); - return bld.create(lhs.getLoc(), lhs, rhsVal); + return mlir::LLVM::AndOp::create(bld, lhs.getLoc(), lhs, rhsVal); } #endif // LLVM_CLANG_LIB_LOWERINGHELPERS_H diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp index 52e9adb75ba0..04749f5d2da2 100644 --- a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp +++ b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp @@ -466,32 +466,31 @@ class CIRWhileOpLowering : public mlir::OpConversionPattern { auto boolTy = rewriter.getType(); auto boolPtrTy = cir::PointerType::get(boolTy); auto alignment = rewriter.getI64IntegerAttr(4); - auto condAlloca = rewriter.create(loc, boolPtrTy, boolTy, - "condition", alignment); + auto condAlloca = AllocaOp::create(rewriter, loc, boolPtrTy, boolTy, + "condition", alignment); rewriter.setInsertionPoint(ifOp); - auto negated = rewriter.create(loc, boolTy, UnaryOpKind::Not, - ifOp.getCondition()); - rewriter.create(loc, negated, condAlloca); + auto negated = UnaryOp::create(rewriter, loc, boolTy, UnaryOpKind::Not, + ifOp.getCondition()); + StoreOp::create(rewriter, loc, negated, condAlloca); // On each layer, surround everything after runner in its parent with a // guard: `if (!condAlloca)`. for (mlir::Operation *runner = ifOp; runner != whileOp; runner = runner->getParentOp()) { rewriter.setInsertionPointAfter(runner); - auto cond = rewriter.create( - loc, boolTy, condAlloca, /*isDeref=*/false, + auto cond = LoadOp::create( + rewriter, loc, boolTy, condAlloca, /*isDeref=*/false, /*volatile=*/false, /*nontemporal=*/false, alignment, /*memorder=*/cir::MemOrderAttr{}, /*tbaa=*/cir::TBAAAttr{}); - auto ifnot = - rewriter.create(loc, cond, /*withElseRegion=*/false, + auto ifnot = IfOp::create(rewriter, loc, cond, /*withElseRegion=*/false, [&](mlir::OpBuilder &, mlir::Location) { /* Intentionally left empty */ }); auto ®ion = ifnot.getThenRegion(); rewriter.setInsertionPointToEnd(®ion.back()); - auto terminator = rewriter.create(loc); + auto terminator = YieldOp::create(rewriter, loc); bool inserted = false; for (mlir::Operation *op = ifnot->getNextNode(); op;) { @@ -509,7 +508,7 @@ class CIRWhileOpLowering : public mlir::OpConversionPattern { rewriter.eraseOp(ifnot); } rewriter.setInsertionPoint(continueOp); - rewriter.create(continueOp->getLoc()); + mlir::scf::YieldOp::create(rewriter, continueOp->getLoc()); rewriter.eraseOp(continueOp); } diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp index 10a8c7e82939..8fa762491be1 100644 --- a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp +++ b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp @@ -48,19 +48,17 @@ #include "mlir/Transforms/DialectConversion.h" #include "clang/CIR/Dialect/IR/CIRDialect.h" #include "clang/CIR/Dialect/IR/CIRTypes.h" +#include "clang/CIR/Interfaces/CIRLoopOpInterface.h" #include "clang/CIR/LowerToLLVM.h" #include "clang/CIR/LowerToMLIR.h" #include "clang/CIR/LoweringHelpers.h" #include "clang/CIR/Passes.h" #include "llvm/ADT/STLExtras.h" -#include "llvm/Support/ErrorHandling.h" -#include "clang/CIR/Interfaces/CIRLoopOpInterface.h" -#include "clang/CIR/LowerToLLVM.h" -#include "clang/CIR/Passes.h" #include "llvm/ADT/Sequence.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/TypeSwitch.h" #include "llvm/IR/Value.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/TimeProfiler.h" using namespace cir; @@ -167,22 +165,23 @@ class CIRCallOpLowering : public mlir::OpConversionPattern { mlir::IntegerType::get(context, 8), initialvalueAttr.getNumElements()); - auto llvmglobalOp = rewriter.create( - globalOp->getLoc(), type, true, mlir::LLVM::Linkage::Internal, + auto llvmglobalOp = mlir::LLVM::GlobalOp::create( + rewriter, globalOp->getLoc(), type, true, + mlir::LLVM::Linkage::Internal, "printf_format_" + globalOp.getSymName().str(), initialvalueAttr, 0); rewriter.setInsertionPoint(getGlobalOp); // Insert llvmir dialect ops to retrive the !llvm.ptr of the global - auto globalPtrOp = rewriter.create( - getGlobalOp->getLoc(), llvmglobalOp); + auto globalPtrOp = mlir::LLVM::AddressOfOp::create( + rewriter, getGlobalOp->getLoc(), llvmglobalOp); - mlir::Value cst0 = rewriter.create( - getGlobalOp->getLoc(), rewriter.getI8Type(), + mlir::Value cst0 = mlir::LLVM::ConstantOp::create( + rewriter, getGlobalOp->getLoc(), rewriter.getI8Type(), rewriter.getIndexAttr(0)); - auto gepPtrOp = rewriter.create( - getGlobalOp->getLoc(), + auto gepPtrOp = mlir::LLVM::GEPOp::create( + rewriter, getGlobalOp->getLoc(), mlir::LLVM::LLVMPointerType::get(context), llvmglobalOp.getType(), globalPtrOp, ArrayRef({cst0, cst0})); @@ -381,12 +380,12 @@ class CIRLoadOpLowering : public mlir::OpConversionPattern { mlir::memref::LoadOp newLoad; if (findBaseAndIndices(adaptor.getAddr(), base, indices, eraseList, rewriter)) { - newLoad = rewriter.create( - op.getLoc(), base, indices, op.getIsNontemporal()); + newLoad = mlir::memref::LoadOp::create(rewriter, op.getLoc(), base, + indices, op.getIsNontemporal()); eraseIfSafe(op.getAddr(), base, eraseList, rewriter); } else - newLoad = rewriter.create( - op.getLoc(), adaptor.getAddr(), mlir::ValueRange{}, + newLoad = mlir::memref::LoadOp::create( + rewriter, op.getLoc(), adaptor.getAddr(), mlir::ValueRange{}, op.getIsNontemporal()); // Convert adapted result to its original type if needed. @@ -531,24 +530,24 @@ class CIRBitClrsbOpLowering mlir::ConversionPatternRewriter &rewriter) const override { auto inputTy = adaptor.getInput().getType(); auto zero = getConst(rewriter, op.getLoc(), inputTy, 0); - auto isNeg = rewriter.create( - op.getLoc(), + auto isNeg = mlir::arith::CmpIOp::create( + rewriter, op.getLoc(), mlir::arith::CmpIPredicateAttr::get(rewriter.getContext(), mlir::arith::CmpIPredicate::slt), adaptor.getInput(), zero); auto negOne = getConst(rewriter, op.getLoc(), inputTy, -1); - auto flipped = rewriter.create( - op.getLoc(), adaptor.getInput(), negOne); + auto flipped = mlir::arith::XOrIOp::create(rewriter, op.getLoc(), + adaptor.getInput(), negOne); - auto select = rewriter.create( - op.getLoc(), isNeg, flipped, adaptor.getInput()); + auto select = mlir::arith::SelectOp::create(rewriter, op.getLoc(), isNeg, + flipped, adaptor.getInput()); auto clz = - rewriter.create(op->getLoc(), select); + mlir::math::CountLeadingZerosOp::create(rewriter, op->getLoc(), select); auto one = getConst(rewriter, op.getLoc(), inputTy, 1); - auto res = rewriter.create(op.getLoc(), clz, one); + auto res = mlir::arith::SubIOp::create(rewriter, op.getLoc(), clz, one); rewriter.replaceOp(op, res); return mlir::LogicalResult::success(); @@ -563,22 +562,22 @@ class CIRBitFfsOpLowering : public mlir::OpConversionPattern { matchAndRewrite(cir::BitFfsOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { auto inputTy = adaptor.getInput().getType(); - auto ctz = rewriter.create( - op.getLoc(), adaptor.getInput()); + auto ctz = mlir::math::CountTrailingZerosOp::create(rewriter, op.getLoc(), + adaptor.getInput()); auto one = getConst(rewriter, op.getLoc(), inputTy, 1); auto ctzAddOne = - rewriter.create(op.getLoc(), ctz, one); + mlir::arith::AddIOp::create(rewriter, op.getLoc(), ctz, one); auto zero = getConst(rewriter, op.getLoc(), inputTy, 0); - auto isZero = rewriter.create( - op.getLoc(), + auto isZero = mlir::arith::CmpIOp::create( + rewriter, op.getLoc(), mlir::arith::CmpIPredicateAttr::get(rewriter.getContext(), mlir::arith::CmpIPredicate::eq), adaptor.getInput(), zero); - auto res = rewriter.create(op.getLoc(), isZero, zero, - ctzAddOne); + auto res = mlir::arith::SelectOp::create(rewriter, op.getLoc(), isZero, + zero, ctzAddOne); rewriter.replaceOp(op, res); return mlir::LogicalResult::success(); @@ -607,9 +606,9 @@ class CIRBitParityOpLowering matchAndRewrite(cir::BitParityOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { auto count = - rewriter.create(op.getLoc(), adaptor.getInput()); - auto countMod2 = rewriter.create( - op.getLoc(), count, + mlir::math::CtPopOp::create(rewriter, op.getLoc(), adaptor.getInput()); + auto countMod2 = mlir::arith::AndIOp::create( + rewriter, op.getLoc(), count, getConst(rewriter, op.getLoc(), count.getType(), 1)); rewriter.replaceOp(op, countMod2); return mlir::LogicalResult::success(); @@ -690,8 +689,8 @@ class CIRFuncOpLowering : public mlir::OpConversionPattern { auto llvmFnType = mlir::LLVM::LLVMFunctionType::get(llvmI32Ty, llvmPtrTy, /*isVarArg=*/true); - auto printfFunc = rewriter.create( - op.getLoc(), "printf", llvmFnType); + auto printfFunc = mlir::LLVM::LLVMFuncOp::create(rewriter, op.getLoc(), + "printf", llvmFnType); rewriter.replaceOp(op, printfFunc); } else { rewriter.eraseOp(op); @@ -717,8 +716,8 @@ class CIRFuncOpLowering : public mlir::OpConversionPattern { mlir::Type resultType = getTypeConverter()->convertType(fnType.getReturnType()); - auto fn = rewriter.create( - op.getLoc(), op.getName(), + auto fn = mlir::func::FuncOp::create( + rewriter, op.getLoc(), op.getName(), rewriter.getFunctionType(signatureConversion.getConvertedTypes(), resultType ? mlir::TypeRange(resultType) : mlir::TypeRange()), @@ -747,14 +746,14 @@ class CIRUnaryOpLowering : public mlir::OpConversionPattern { switch (op.getKind()) { case cir::UnaryOpKind::Inc: { - auto One = rewriter.create( - op.getLoc(), mlir::IntegerAttr::get(type, 1)); + auto One = mlir::arith::ConstantOp::create( + rewriter, op.getLoc(), mlir::IntegerAttr::get(type, 1)); rewriter.replaceOpWithNewOp(op, type, input, One); break; } case cir::UnaryOpKind::Dec: { - auto One = rewriter.create( - op.getLoc(), mlir::IntegerAttr::get(type, 1)); + auto One = mlir::arith::ConstantOp::create( + rewriter, op.getLoc(), mlir::IntegerAttr::get(type, 1)); rewriter.replaceOpWithNewOp(op, type, input, One); break; } @@ -763,14 +762,14 @@ class CIRUnaryOpLowering : public mlir::OpConversionPattern { break; } case cir::UnaryOpKind::Minus: { - auto Zero = rewriter.create( - op.getLoc(), mlir::IntegerAttr::get(type, 0)); + auto Zero = mlir::arith::ConstantOp::create( + rewriter, op.getLoc(), mlir::IntegerAttr::get(type, 0)); rewriter.replaceOpWithNewOp(op, type, Zero, input); break; } case cir::UnaryOpKind::Not: { - auto MinusOne = rewriter.create( - op.getLoc(), mlir::IntegerAttr::get(type, -1)); + auto MinusOne = mlir::arith::ConstantOp::create( + rewriter, op.getLoc(), mlir::IntegerAttr::get(type, -1)); rewriter.replaceOpWithNewOp(op, type, MinusOne, input); break; @@ -937,8 +936,8 @@ class CIRScopeOpLowering : public mlir::OpConversionPattern { // For scopes without results, use memref.alloca_scope if (scopeOp.getNumResults() == 0) { - auto allocaScope = rewriter.create( - scopeOp.getLoc(), mlir::TypeRange{}); + auto allocaScope = mlir::memref::AllocaScopeOp::create( + rewriter, scopeOp.getLoc(), mlir::TypeRange{}); rewriter.inlineRegionBefore(scopeOp.getScopeRegion(), allocaScope.getBodyRegion(), allocaScope.getBodyRegion().end()); @@ -946,11 +945,11 @@ class CIRScopeOpLowering : public mlir::OpConversionPattern { } else { // For scopes with results, use scf.execute_region SmallVector types; - if (mlir::failed( - getTypeConverter()->convertTypes(scopeOp->getResultTypes(), types))) + if (mlir::failed(getTypeConverter()->convertTypes( + scopeOp->getResultTypes(), types))) return mlir::failure(); auto exec = - rewriter.create(scopeOp.getLoc(), types); + mlir::scf::ExecuteRegionOp::create(rewriter, scopeOp.getLoc(), types); rewriter.inlineRegionBefore(scopeOp.getScopeRegion(), exec.getRegion(), exec.getRegion().end()); rewriter.replaceOp(scopeOp, exec.getResults()); @@ -987,8 +986,8 @@ class CIRTernaryOpLowering : public mlir::OpConversionPattern { resultTypes))) return mlir::failure(); - auto ifOp = rewriter.create(op.getLoc(), resultTypes, - adaptor.getCond(), true); + auto ifOp = mlir::scf::IfOp::create(rewriter, op.getLoc(), resultTypes, + adaptor.getCond(), true); auto *thenBlock = &ifOp.getThenRegion().front(); auto *elseBlock = &ifOp.getElseRegion().front(); rewriter.inlineBlockBefore(&op.getTrueRegion().front(), thenBlock, @@ -1030,8 +1029,9 @@ class CIRIfOpLowering : public mlir::OpConversionPattern { mlir::LogicalResult matchAndRewrite(cir::IfOp ifop, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { - auto newIfOp = rewriter.create( - ifop->getLoc(), ifop->getResultTypes(), adaptor.getCondition()); + auto newIfOp = + mlir::scf::IfOp::create(rewriter, ifop->getLoc(), + ifop->getResultTypes(), adaptor.getCondition()); auto *thenBlock = rewriter.createBlock(&newIfOp.getThenRegion()); rewriter.inlineBlockBefore(&ifop.getThenRegion().front(), thenBlock, thenBlock->end()); @@ -1166,8 +1166,8 @@ class CIRVectorCreateLowering auto elementTy = typeConverter->convertType(vecTy.getElementType()); auto loc = op.getLoc(); auto zeroElement = rewriter.getZeroAttr(elementTy); - mlir::Value result = rewriter.create( - loc, + mlir::Value result = mlir::arith::ConstantOp::create( + rewriter, loc, mlir::DenseElementsAttr::get( mlir::VectorType::get(vecTy.getSize(), elementTy), zeroElement)); assert(vecTy.getSize() == op.getElements().size() && @@ -1175,8 +1175,8 @@ class CIRVectorCreateLowering for (uint64_t i = 0; i < vecTy.getSize(); ++i) { mlir::Value indexValue = getConst(rewriter, loc, rewriter.getI64Type(), i); - result = rewriter.create( - loc, adaptor.getElements()[i], result, indexValue); + result = mlir::vector::InsertElementOp::create( + rewriter, loc, adaptor.getElements()[i], result, indexValue); } rewriter.replaceOp(op, result); return mlir::success(); @@ -1226,13 +1226,13 @@ class CIRVectorCmpOpLowering : public mlir::OpConversionPattern { mlir::cast(op.getLhs().getType()).getElementType(); mlir::Value bitResult; if (auto intType = mlir::dyn_cast(elementType)) { - bitResult = rewriter.create( - op.getLoc(), + bitResult = mlir::arith::CmpIOp::create( + rewriter, op.getLoc(), convertCmpKindToCmpIPredicate(op.getKind(), intType.isSigned()), adaptor.getLhs(), adaptor.getRhs()); } else if (mlir::isa(elementType)) { - bitResult = rewriter.create( - op.getLoc(), convertCmpKindToCmpFPredicate(op.getKind()), + bitResult = mlir::arith::CmpFOp::create( + rewriter, op.getLoc(), convertCmpKindToCmpFPredicate(op.getKind()), adaptor.getLhs(), adaptor.getRhs()); } else { return op.emitError() << "unsupported type for VecCmpOp: " << elementType; @@ -1268,9 +1268,9 @@ class CIRCastOpLowering : public mlir::OpConversionPattern { return mlir::success(); } case CIR::int_to_bool: { - auto zero = rewriter.create( - src.getLoc(), op.getSrc().getType(), - cir::IntAttr::get(op.getSrc().getType(), 0)); + auto zero = + cir::ConstantOp::create(rewriter, src.getLoc(), op.getSrc().getType(), + cir::IntAttr::get(op.getSrc().getType(), 0)); rewriter.replaceOpWithNewOp( op, cir::BoolType::get(getContext()), cir::CmpOpKind::ne, op.getSrc(), zero); @@ -1308,8 +1308,9 @@ class CIRCastOpLowering : public mlir::OpConversionPattern { auto kind = mlir::arith::CmpFPredicate::UNE; // Check if float is not equal to zero. - auto zeroFloat = rewriter.create( - op.getLoc(), src.getType(), mlir::FloatAttr::get(src.getType(), 0.0)); + auto zeroFloat = mlir::arith::ConstantOp::create( + rewriter, op.getLoc(), src.getType(), + mlir::FloatAttr::get(src.getType(), 0.0)); rewriter.replaceOpWithNewOp(op, kind, src, zeroFloat); @@ -1387,8 +1388,8 @@ class CIRGetElementOpLowering auto index = adaptor.getIndex(); auto indexType = rewriter.getIndexType(); if (index.getType() != indexType) - index = rewriter.create(op.getLoc(), indexType, - index); + index = mlir::arith::IndexCastOp::create(rewriter, op.getLoc(), indexType, + index); // Convert the destination type. auto dstType = @@ -1475,8 +1476,8 @@ class CIRPtrStrideOpLowering auto indexType = rewriter.getIndexType(); // Generate casting if the stride is not index type. if (stride.getType() != indexType) - stride = rewriter.create(op.getLoc(), indexType, - stride); + stride = mlir::arith::IndexCastOp::create(rewriter, op.getLoc(), + indexType, stride); rewriter.replaceOpWithNewOp( op, newDstType, base, stride, mlir::ValueRange{}, mlir::ValueRange{}, llvm::ArrayRef{}); @@ -1507,9 +1508,10 @@ class CIRTrapOpLowering : public mlir::OpConversionPattern { mlir::ConversionPatternRewriter &rewriter) const override { rewriter.setInsertionPointAfter(op); auto trapIntrinsicName = rewriter.getStringAttr("llvm.trap"); - rewriter.create(op.getLoc(), trapIntrinsicName, - /*args=*/mlir::ValueRange()); - rewriter.create(op.getLoc()); + mlir::LLVM::CallIntrinsicOp::create(rewriter, op.getLoc(), + trapIntrinsicName, + /*args=*/mlir::ValueRange()); + mlir::LLVM::UnreachableOp::create(rewriter, op.getLoc()); rewriter.eraseOp(op); return mlir::success(); } @@ -1519,24 +1521,23 @@ void populateCIRToMLIRConversionPatterns(mlir::RewritePatternSet &patterns, mlir::TypeConverter &converter) { patterns.add(patterns.getContext()); - patterns - .add(converter, patterns.getContext()); + patterns.add< + CIRATanOpLowering, CIRCmpOpLowering, CIRCallOpLowering, + CIRUnaryOpLowering, CIRBinOpLowering, CIRLoadOpLowering, + CIRConstantOpLowering, CIRStoreOpLowering, CIRAllocaOpLowering, + CIRFuncOpLowering, CIRBrCondOpLowering, CIRTernaryOpLowering, + CIRYieldOpLowering, CIRCosOpLowering, CIRGlobalOpLowering, + CIRGetGlobalOpLowering, CIRCastOpLowering, CIRPtrStrideOpLowering, + CIRGetElementOpLowering, CIRSqrtOpLowering, CIRCeilOpLowering, + CIRExp2OpLowering, CIRExpOpLowering, CIRFAbsOpLowering, CIRAbsOpLowering, + CIRFloorOpLowering, CIRLog10OpLowering, CIRLog2OpLowering, + CIRLogOpLowering, CIRRoundOpLowering, CIRSinOpLowering, + CIRShiftOpLowering, CIRBitClzOpLowering, CIRBitCtzOpLowering, + CIRBitPopcountOpLowering, CIRBitClrsbOpLowering, CIRBitFfsOpLowering, + CIRBitParityOpLowering, CIRIfOpLowering, CIRVectorCreateLowering, + CIRVectorInsertLowering, CIRVectorExtractLowering, CIRVectorCmpOpLowering, + CIRACosOpLowering, CIRASinOpLowering, CIRUnreachableOpLowering, + CIRTanOpLowering, CIRTrapOpLowering>(converter, patterns.getContext()); } static mlir::TypeConverter prepareTypeConverter() { @@ -1610,7 +1611,7 @@ void ConvertCIRToMLIRPass::runOnOperation() { mlir::ModuleOp theModule = getOperation(); auto converter = prepareTypeConverter(); - + mlir::RewritePatternSet patterns(&getContext()); populateCIRLoopToSCFConversionPatterns(patterns, converter); @@ -1628,10 +1629,11 @@ void ConvertCIRToMLIRPass::runOnOperation() { // cir dialect, for example the `cir.continue`. If we marked cir as illegal // here, then MLIR would think any remaining `cir.continue` indicates a // failure, which is not what we want. - - patterns.add(converter, context); - if (mlir::failed(mlir::applyPartialConversion(theModule, target, + patterns.add(converter, context); + + if (mlir::failed(mlir::applyPartialConversion(theModule, target, std::move(patterns)))) { signalPassFailure(); } diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerToMLIRHelpers.h b/clang/lib/CIR/Lowering/ThroughMLIR/LowerToMLIRHelpers.h index 34769e7d29dc..b6593772d99d 100644 --- a/clang/lib/CIR/Lowering/ThroughMLIR/LowerToMLIRHelpers.h +++ b/clang/lib/CIR/Lowering/ThroughMLIR/LowerToMLIRHelpers.h @@ -11,10 +11,10 @@ mlir::Value getConst(mlir::ConversionPatternRewriter &rewriter, mlir::Location loc, mlir::Type ty, T value) { assert(mlir::isa(ty) || mlir::isa(ty)); if (mlir::isa(ty)) - return rewriter.create( - loc, ty, mlir::IntegerAttr::get(ty, value)); - return rewriter.create( - loc, ty, mlir::FloatAttr::get(ty, value)); + return mlir::arith::ConstantOp::create(rewriter, loc, ty, + mlir::IntegerAttr::get(ty, value)); + return mlir::arith::ConstantOp::create(rewriter, loc, ty, + mlir::FloatAttr::get(ty, value)); } mlir::Value createIntCast(mlir::ConversionPatternRewriter &rewriter, @@ -29,13 +29,13 @@ mlir::Value createIntCast(mlir::ConversionPatternRewriter &rewriter, auto loc = src.getLoc(); if (dstWidth > srcWidth && isSigned) - return rewriter.create(loc, dstTy, src); + return mlir::arith::ExtSIOp::create(rewriter, loc, dstTy, src); else if (dstWidth > srcWidth) - return rewriter.create(loc, dstTy, src); + return mlir::arith::ExtUIOp::create(rewriter, loc, dstTy, src); else if (dstWidth < srcWidth) - return rewriter.create(loc, dstTy, src); + return mlir::arith::TruncIOp::create(rewriter, loc, dstTy, src); else - return rewriter.create(loc, dstTy, src); + return mlir::arith::BitcastOp::create(rewriter, loc, dstTy, src); } mlir::arith::CmpIPredicate convertCmpKindToCmpIPredicate(cir::CmpOpKind kind,