20class ComplexExprEmitter :
public StmtVisitor<ComplexExprEmitter, mlir::Value> {
22 CIRGenBuilderTy &builder;
25 explicit ComplexExprEmitter(CIRGenFunction &cgf)
26 : cgf(cgf), builder(cgf.getBuilder()) {}
35 mlir::Value emitLoadOfLValue(
const Expr *e) {
36 return emitLoadOfLValue(cgf.emitLValue(e), e->
getExprLoc());
39 mlir::Value emitLoadOfLValue(LValue lv, SourceLocation loc);
43 void emitStoreOfComplex(mlir::Location loc, mlir::Value val, LValue lv,
47 mlir::Value emitComplexToComplexCast(mlir::Value value, QualType srcType,
48 QualType destType, SourceLocation loc);
51 mlir::Value emitScalarToComplexCast(mlir::Value value, QualType srcType,
52 QualType destType, SourceLocation loc);
58 mlir::Value Visit(Expr *e) {
59 return StmtVisitor<ComplexExprEmitter, mlir::Value>::Visit(e);
62 mlir::Value VisitStmt(Stmt *
s) {
63 cgf.cgm.errorNYI(
s->getBeginLoc(),
"ComplexExprEmitter VisitStmt");
67 mlir::Value VisitExpr(Expr *e);
68 mlir::Value VisitConstantExpr(ConstantExpr *e) {
69 cgf.cgm.errorNYI(e->
getExprLoc(),
"ComplexExprEmitter VisitConstantExpr");
73 mlir::Value VisitParenExpr(ParenExpr *pe) {
return Visit(pe->
getSubExpr()); }
74 mlir::Value VisitGenericSelectionExpr(GenericSelectionExpr *ge) {
77 mlir::Value VisitImaginaryLiteral(
const ImaginaryLiteral *il);
79 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *pe) {
82 mlir::Value VisitCoawaitExpr(CoawaitExpr *
s) {
83 cgf.cgm.errorNYI(
s->getExprLoc(),
"ComplexExprEmitter VisitCoawaitExpr");
86 mlir::Value VisitCoyieldExpr(CoyieldExpr *
s) {
87 cgf.cgm.errorNYI(
s->getExprLoc(),
"ComplexExprEmitter VisitCoyieldExpr");
90 mlir::Value VisitUnaryCoawait(
const UnaryOperator *e) {
91 cgf.cgm.errorNYI(e->
getExprLoc(),
"ComplexExprEmitter VisitUnaryCoawait");
95 mlir::Value emitConstant(
const CIRGenFunction::ConstantEmission &constant,
97 assert(constant &&
"not a constant");
102 mlir::TypedAttr valueAttr = constant.
getValue();
103 return builder.getConstant(cgf.getLoc(e->
getSourceRange()), valueAttr);
107 mlir::Value VisitDeclRefExpr(DeclRefExpr *e) {
108 if (CIRGenFunction::ConstantEmission constant = cgf.tryEmitAsConstant(e))
109 return emitConstant(constant, e);
110 return emitLoadOfLValue(e);
112 mlir::Value VisitObjCIvarRefExpr(ObjCIvarRefExpr *e) {
114 "ComplexExprEmitter VisitObjCIvarRefExpr");
117 mlir::Value VisitObjCMessageExpr(ObjCMessageExpr *e) {
119 "ComplexExprEmitter VisitObjCMessageExpr");
122 mlir::Value VisitArraySubscriptExpr(Expr *e) {
return emitLoadOfLValue(e); }
123 mlir::Value VisitMemberExpr(MemberExpr *me) {
124 if (CIRGenFunction::ConstantEmission constant = cgf.tryEmitAsConstant(me)) {
125 cgf.emitIgnoredExpr(me->
getBase());
126 return emitConstant(constant, me);
128 return emitLoadOfLValue(me);
130 mlir::Value VisitOpaqueValueExpr(OpaqueValueExpr *e) {
132 return emitLoadOfLValue(cgf.getOrCreateOpaqueLValueMapping(e),
134 return cgf.getOrCreateOpaqueRValueMapping(e).getComplexValue();
137 mlir::Value VisitPseudoObjectExpr(PseudoObjectExpr *e) {
139 "ComplexExprEmitter VisitPseudoObjectExpr");
143 mlir::Value emitCast(
CastKind ck, Expr *op, QualType destTy);
144 mlir::Value VisitImplicitCastExpr(ImplicitCastExpr *e) {
148 return emitLoadOfLValue(e);
151 mlir::Value VisitCastExpr(
CastExpr *e) {
152 if (
const auto *ece = dyn_cast<ExplicitCastExpr>(e)) {
154 if (ece->getType()->isVariablyModifiedType()) {
156 "VisitCastExpr Bind VLAs in the cast type");
162 return emitLoadOfLValue(e);
166 mlir::Value VisitCallExpr(
const CallExpr *e);
167 mlir::Value VisitStmtExpr(
const StmtExpr *e);
170 mlir::Value VisitPrePostIncDec(
const UnaryOperator *e, cir::UnaryOpKind op,
173 return cgf.emitComplexPrePostIncDec(e, lv, op, isPre);
175 mlir::Value VisitUnaryPostDec(
const UnaryOperator *e) {
176 return VisitPrePostIncDec(e, cir::UnaryOpKind::Dec,
false);
178 mlir::Value VisitUnaryPostInc(
const UnaryOperator *e) {
179 return VisitPrePostIncDec(e, cir::UnaryOpKind::Inc,
false);
181 mlir::Value VisitUnaryPreDec(
const UnaryOperator *e) {
182 return VisitPrePostIncDec(e, cir::UnaryOpKind::Dec,
true);
184 mlir::Value VisitUnaryPreInc(
const UnaryOperator *e) {
185 return VisitPrePostIncDec(e, cir::UnaryOpKind::Inc,
true);
187 mlir::Value VisitUnaryDeref(
const Expr *e) {
return emitLoadOfLValue(e); }
189 mlir::Value VisitUnaryPlus(
const UnaryOperator *e);
190 mlir::Value VisitUnaryMinus(
const UnaryOperator *e);
191 mlir::Value VisitPlusMinus(
const UnaryOperator *e, cir::UnaryOpKind kind,
192 QualType promotionType);
193 mlir::Value VisitUnaryNot(
const UnaryOperator *e);
195 mlir::Value VisitUnaryExtension(
const UnaryOperator *e) {
198 mlir::Value VisitCXXDefaultArgExpr(CXXDefaultArgExpr *dae) {
200 "ComplexExprEmitter VisitCXXDefaultArgExpr");
203 mlir::Value VisitCXXDefaultInitExpr(CXXDefaultInitExpr *die) {
204 CIRGenFunction::CXXDefaultInitExprScope scope(cgf, die);
207 mlir::Value VisitExprWithCleanups(ExprWithCleanups *e) {
209 "ComplexExprEmitter VisitExprWithCleanups");
212 mlir::Value VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *e) {
213 mlir::Location loc = cgf.getLoc(e->
getExprLoc());
214 mlir::Type complexTy = cgf.convertType(e->
getType());
215 return builder.getNullValue(complexTy, loc);
217 mlir::Value VisitImplicitValueInitExpr(ImplicitValueInitExpr *e) {
219 "ComplexExprEmitter VisitImplicitValueInitExpr");
228 FPOptions fpFeatures{};
231 BinOpInfo emitBinOps(
const BinaryOperator *e,
232 QualType promotionTy = QualType());
234 mlir::Value emitPromoted(
const Expr *e, QualType promotionTy);
235 mlir::Value emitPromotedComplexOperand(
const Expr *e, QualType promotionTy);
236 LValue emitCompoundAssignLValue(
237 const CompoundAssignOperator *e,
238 mlir::Value (ComplexExprEmitter::*func)(
const BinOpInfo &),
240 mlir::Value emitCompoundAssign(
241 const CompoundAssignOperator *e,
242 mlir::Value (ComplexExprEmitter::*func)(
const BinOpInfo &));
244 mlir::Value emitBinAdd(
const BinOpInfo &op);
245 mlir::Value emitBinSub(
const BinOpInfo &op);
246 mlir::Value emitBinMul(
const BinOpInfo &op);
247 mlir::Value emitBinDiv(
const BinOpInfo &op);
249 QualType getPromotionType(QualType ty,
bool isDivOpCode =
false) {
250 if (
auto *complexTy = ty->
getAs<ComplexType>()) {
251 QualType elementTy = complexTy->getElementType();
253 return cgf.getContext().getComplexType(cgf.getContext().FloatTy);
257 return cgf.getContext().FloatTy;
261#define HANDLEBINOP(OP) \
262 mlir::Value VisitBin##OP(const BinaryOperator *e) { \
263 QualType promotionTy = getPromotionType( \
264 e->getType(), e->getOpcode() == BinaryOperatorKind::BO_Div); \
265 mlir::Value result = emitBin##OP(emitBinOps(e, promotionTy)); \
266 if (!promotionTy.isNull()) \
267 result = cgf.emitUnPromotedValue(result, e->getType()); \
279 "ComplexExprEmitter VisitCXXRewrittenBinaryOperator");
284 mlir::Value VisitBinAddAssign(
const CompoundAssignOperator *e) {
285 return emitCompoundAssign(e, &ComplexExprEmitter::emitBinAdd);
287 mlir::Value VisitBinSubAssign(
const CompoundAssignOperator *e) {
288 return emitCompoundAssign(e, &ComplexExprEmitter::emitBinSub);
290 mlir::Value VisitBinMulAssign(
const CompoundAssignOperator *e) {
291 return emitCompoundAssign(e, &ComplexExprEmitter::emitBinMul);
293 mlir::Value VisitBinDivAssign(
const CompoundAssignOperator *e) {
294 return emitCompoundAssign(e, &ComplexExprEmitter::emitBinDiv);
302 LValue emitBinAssignLValue(
const BinaryOperator *e, mlir::Value &val);
303 mlir::Value VisitBinAssign(
const BinaryOperator *e);
304 mlir::Value VisitBinComma(
const BinaryOperator *e);
307 VisitAbstractConditionalOperator(
const AbstractConditionalOperator *e);
308 mlir::Value VisitChooseExpr(ChooseExpr *e);
310 mlir::Value VisitInitListExpr(InitListExpr *e);
312 mlir::Value VisitCompoundLiteralExpr(CompoundLiteralExpr *e) {
313 return emitLoadOfLValue(e);
316 mlir::Value VisitVAArgExpr(VAArgExpr *e);
318 mlir::Value VisitAtomicExpr(AtomicExpr *e) {
319 cgf.cgm.errorNYI(e->
getExprLoc(),
"ComplexExprEmitter VisitAtomicExpr");
323 mlir::Value VisitPackIndexingExpr(PackIndexingExpr *e) {
325 "ComplexExprEmitter VisitPackIndexingExpr");
337mlir::Value ComplexExprEmitter::emitLoadOfLValue(LValue lv,
339 assert(lv.isSimple() &&
"non-simple complex l-value?");
340 if (lv.getType()->isAtomicType())
341 cgf.
cgm.
errorNYI(loc,
"emitLoadOfLValue with Atomic LV");
343 const Address srcAddr = lv.getAddress();
349void ComplexExprEmitter::emitStoreOfComplex(mlir::Location loc, mlir::Value val,
350 LValue lv,
bool isInit) {
351 if (lv.getType()->isAtomicType() ||
353 cgf.
cgm.
errorNYI(loc,
"StoreOfComplex with Atomic LV");
357 const Address destAddr = lv.getAddress();
365mlir::Value ComplexExprEmitter::VisitExpr(Expr *e) {
371ComplexExprEmitter::VisitImaginaryLiteral(
const ImaginaryLiteral *il) {
373 mlir::Type elementTy = ty.getElementType();
376 mlir::TypedAttr realValueAttr;
377 mlir::TypedAttr imagValueAttr;
379 if (mlir::isa<cir::IntType>(elementTy)) {
381 realValueAttr = cir::IntAttr::get(elementTy, 0);
382 imagValueAttr = cir::IntAttr::get(elementTy, imagValue);
384 assert(mlir::isa<cir::FPTypeInterface>(elementTy) &&
385 "Expected complex element type to be floating-point");
387 llvm::APFloat imagValue =
389 realValueAttr = cir::FPAttr::get(
390 elementTy, llvm::APFloat::getZero(imagValue.getSemantics()));
391 imagValueAttr = cir::FPAttr::get(elementTy, imagValue);
394 auto complexAttr = cir::ConstComplexAttr::get(realValueAttr, imagValueAttr);
395 return builder.create<cir::ConstantOp>(loc, complexAttr);
398mlir::Value ComplexExprEmitter::VisitCallExpr(
const CallExpr *e) {
400 return emitLoadOfLValue(e);
404mlir::Value ComplexExprEmitter::VisitStmtExpr(
const StmtExpr *e) {
409mlir::Value ComplexExprEmitter::emitComplexToComplexCast(mlir::Value val,
412 SourceLocation loc) {
413 if (srcType == destType)
417 QualType srcElemTy = srcType->
castAs<ComplexType>()->getElementType();
418 QualType destElemTy = destType->
castAs<ComplexType>()->getElementType();
420 cir::CastKind castOpKind;
422 castOpKind = cir::CastKind::float_complex;
424 castOpKind = cir::CastKind::float_complex_to_int_complex;
426 castOpKind = cir::CastKind::int_complex_to_float_complex;
428 castOpKind = cir::CastKind::int_complex;
430 llvm_unreachable(
"unexpected src type or dest type");
436mlir::Value ComplexExprEmitter::emitScalarToComplexCast(mlir::Value val,
439 SourceLocation loc) {
440 cir::CastKind castOpKind;
442 castOpKind = cir::CastKind::float_to_complex;
444 castOpKind = cir::CastKind::int_to_complex;
446 llvm_unreachable(
"unexpected src type");
452mlir::Value ComplexExprEmitter::emitCast(
CastKind ck, Expr *op,
456 llvm_unreachable(
"dependent type must be resolved before the CIR codegen");
459 case CK_LValueToRValue:
462 case CK_AtomicToNonAtomic:
463 case CK_NonAtomicToAtomic:
464 case CK_UserDefinedConversion: {
466 "ComplexExprEmitter::emitCast Atmoic & UserDefinedConversion");
470 case CK_LValueBitCast: {
473 origLV.getAddress().withElementType(builder, cgf.
convertType(destTy));
475 return emitLoadOfLValue(destLV, op->
getExprLoc());
478 case CK_LValueToRValueBitCast: {
480 Address addr = sourceLVal.getAddress().withElementType(
484 return emitLoadOfLValue(destLV, op->
getExprLoc());
488 case CK_BaseToDerived:
489 case CK_DerivedToBase:
490 case CK_UncheckedDerivedToBase:
493 case CK_ArrayToPointerDecay:
494 case CK_FunctionToPointerDecay:
495 case CK_NullToPointer:
496 case CK_NullToMemberPointer:
497 case CK_BaseToDerivedMemberPointer:
498 case CK_DerivedToBaseMemberPointer:
499 case CK_MemberPointerToBoolean:
500 case CK_ReinterpretMemberPointer:
501 case CK_ConstructorConversion:
502 case CK_IntegralToPointer:
503 case CK_PointerToIntegral:
504 case CK_PointerToBoolean:
507 case CK_IntegralCast:
508 case CK_BooleanToSignedIntegral:
509 case CK_IntegralToBoolean:
510 case CK_IntegralToFloating:
511 case CK_FloatingToIntegral:
512 case CK_FloatingToBoolean:
513 case CK_FloatingCast:
514 case CK_CPointerToObjCPointerCast:
515 case CK_BlockPointerToObjCPointerCast:
516 case CK_AnyPointerToBlockPointerCast:
517 case CK_ObjCObjectLValueCast:
518 case CK_FloatingComplexToReal:
519 case CK_FloatingComplexToBoolean:
520 case CK_IntegralComplexToReal:
521 case CK_IntegralComplexToBoolean:
522 case CK_ARCProduceObject:
523 case CK_ARCConsumeObject:
524 case CK_ARCReclaimReturnedObject:
525 case CK_ARCExtendBlockObject:
526 case CK_CopyAndAutoreleaseBlockObject:
527 case CK_BuiltinFnToFnPtr:
528 case CK_ZeroToOCLOpaqueType:
529 case CK_AddressSpaceConversion:
530 case CK_IntToOCLSampler:
531 case CK_FloatingToFixedPoint:
532 case CK_FixedPointToFloating:
533 case CK_FixedPointCast:
534 case CK_FixedPointToBoolean:
535 case CK_FixedPointToIntegral:
536 case CK_IntegralToFixedPoint:
538 case CK_HLSLVectorTruncation:
539 case CK_HLSLArrayRValue:
540 case CK_HLSLElementwiseCast:
541 case CK_HLSLAggregateSplatCast:
542 llvm_unreachable(
"invalid cast kind for complex value");
544 case CK_FloatingRealToComplex:
545 case CK_IntegralRealToComplex: {
551 case CK_FloatingComplexCast:
552 case CK_FloatingComplexToIntegralComplex:
553 case CK_IntegralComplexCast:
554 case CK_IntegralComplexToFloatingComplex: {
556 return emitComplexToComplexCast(Visit(op), op->
getType(), destTy,
561 llvm_unreachable(
"unknown cast resulting in complex value");
564mlir::Value ComplexExprEmitter::VisitUnaryPlus(
const UnaryOperator *e) {
566 mlir::Value result = VisitPlusMinus(e, cir::UnaryOpKind::Plus, promotionTy);
567 if (!promotionTy.
isNull())
572mlir::Value ComplexExprEmitter::VisitUnaryMinus(
const UnaryOperator *e) {
574 mlir::Value result = VisitPlusMinus(e, cir::UnaryOpKind::Minus, promotionTy);
575 if (!promotionTy.
isNull())
580mlir::Value ComplexExprEmitter::VisitPlusMinus(
const UnaryOperator *e,
581 cir::UnaryOpKind kind,
582 QualType promotionType) {
583 assert(kind == cir::UnaryOpKind::Plus ||
584 kind == cir::UnaryOpKind::Minus &&
585 "Invalid UnaryOp kind for ComplexType Plus or Minus");
588 if (!promotionType.
isNull())
595mlir::Value ComplexExprEmitter::VisitUnaryNot(
const UnaryOperator *e) {
600mlir::Value ComplexExprEmitter::emitBinAdd(
const BinOpInfo &op) {
604 if (mlir::isa<cir::ComplexType>(op.lhs.getType()) &&
605 mlir::isa<cir::ComplexType>(op.rhs.getType()))
606 return builder.create<cir::ComplexAddOp>(op.loc, op.lhs, op.rhs);
608 if (mlir::isa<cir::ComplexType>(op.lhs.getType())) {
611 mlir::Value newReal = builder.
createAdd(op.loc, real, op.rhs);
615 assert(mlir::isa<cir::ComplexType>(op.rhs.getType()));
618 mlir::Value newReal = builder.
createAdd(op.loc, op.lhs, real);
622mlir::Value ComplexExprEmitter::emitBinSub(
const BinOpInfo &op) {
626 if (mlir::isa<cir::ComplexType>(op.lhs.getType()) &&
627 mlir::isa<cir::ComplexType>(op.rhs.getType()))
628 return builder.create<cir::ComplexSubOp>(op.loc, op.lhs, op.rhs);
630 if (mlir::isa<cir::ComplexType>(op.lhs.getType())) {
633 mlir::Value newReal = builder.
createSub(op.loc, real, op.rhs);
637 assert(mlir::isa<cir::ComplexType>(op.rhs.getType()));
640 mlir::Value newReal = builder.
createSub(op.loc, op.lhs, real);
644static cir::ComplexRangeKind
648 return cir::ComplexRangeKind::Full;
650 return cir::ComplexRangeKind::Improved;
652 return cir::ComplexRangeKind::Promoted;
654 return cir::ComplexRangeKind::Basic;
657 return cir::ComplexRangeKind::Full;
661mlir::Value ComplexExprEmitter::emitBinMul(
const BinOpInfo &op) {
665 if (mlir::isa<cir::ComplexType>(op.lhs.getType()) &&
666 mlir::isa<cir::ComplexType>(op.rhs.getType())) {
667 cir::ComplexRangeKind rangeKind =
669 return builder.create<cir::ComplexMulOp>(op.loc, op.lhs, op.rhs, rangeKind);
672 if (mlir::isa<cir::ComplexType>(op.lhs.getType())) {
675 mlir::Value newReal = builder.
createMul(op.loc, real, op.rhs);
676 mlir::Value newImag = builder.
createMul(op.loc, imag, op.rhs);
680 assert(mlir::isa<cir::ComplexType>(op.rhs.getType()));
683 mlir::Value newReal = builder.
createMul(op.loc, op.lhs, real);
684 mlir::Value newImag = builder.
createMul(op.loc, op.lhs, imag);
688mlir::Value ComplexExprEmitter::emitBinDiv(
const BinOpInfo &op) {
696 if (mlir::isa<cir::ComplexType>(op.lhs.getType()) &&
697 mlir::isa<cir::ComplexType>(op.rhs.getType())) {
698 cir::ComplexRangeKind rangeKind =
700 return cir::ComplexDivOp::create(builder, op.loc, op.lhs, op.rhs,
706 if (mlir::isa<cir::ComplexType>(op.lhs.getType())) {
707 assert(mlir::cast<cir::ComplexType>(op.lhs.getType()).getElementType() ==
711 mlir::Value newReal = builder.
createFDiv(op.loc, real, op.rhs);
712 mlir::Value newImag = builder.
createFDiv(op.loc, imag, op.rhs);
716 assert(mlir::isa<cir::ComplexType>(op.rhs.getType()));
717 cir::ConstantOp nullValue = builder.
getNullValue(op.lhs.getType(), op.loc);
719 cir::ComplexRangeKind rangeKind =
721 return cir::ComplexDivOp::create(builder, op.loc, lhs, op.rhs, rangeKind);
726 assert(!mlir::cast<cir::ComplexType>(result.getType()).isIntegerComplex() &&
727 "integral complex will never be promoted");
728 return builder.createCast(cir::CastKind::float_complex, result,
734 assert(!mlir::cast<cir::ComplexType>(result.getType()).isIntegerComplex() &&
735 "integral complex will never be promoted");
736 return builder.createCast(cir::CastKind::float_complex, result,
740mlir::Value ComplexExprEmitter::emitPromoted(
const Expr *e,
743 if (
const auto *bo = dyn_cast<BinaryOperator>(e)) {
744 switch (bo->getOpcode()) {
745#define HANDLE_BINOP(OP) \
747 return emitBin##OP(emitBinOps(bo, promotionTy));
756 }
else if (
const auto *unaryOp = dyn_cast<UnaryOperator>(e)) {
757 switch (unaryOp->getOpcode()) {
760 auto kind = unaryOp->getOpcode() == UO_Plus ? cir::UnaryOpKind::Plus
761 : cir::UnaryOpKind::Minus;
762 return VisitPlusMinus(unaryOp, kind, promotionTy);
769 mlir::Value result = Visit(
const_cast<Expr *
>(e));
770 if (!promotionTy.
isNull())
778 return ComplexExprEmitter(*this).emitPromoted(e, promotionType);
782ComplexExprEmitter::emitPromotedComplexOperand(
const Expr *e,
785 if (!promotionTy.
isNull())
787 return Visit(
const_cast<Expr *
>(e));
790 if (!promotionTy.
isNull()) {
798ComplexExprEmitter::BinOpInfo
799ComplexExprEmitter::emitBinOps(
const BinaryOperator *e, QualType promotionTy) {
801 binOpInfo.lhs = emitPromotedComplexOperand(e->
getLHS(), promotionTy);
802 binOpInfo.rhs = emitPromotedComplexOperand(e->
getRHS(), promotionTy);
803 binOpInfo.ty = promotionTy.
isNull() ? e->
getType() : promotionTy;
808LValue ComplexExprEmitter::emitCompoundAssignLValue(
809 const CompoundAssignOperator *e,
810 mlir::Value (ComplexExprEmitter::*func)(
const BinOpInfo &), RValue &value) {
814 mlir::Location loc = cgf.
getLoc(exprLoc);
816 if (lhsTy->
getAs<AtomicType>()) {
817 cgf.
cgm.
errorNYI(
"emitCompoundAssignLValue AtmoicType");
821 BinOpInfo opInfo{loc};
833 QualType complexElementTy =
834 opInfo.ty->castAs<ComplexType>()->getElementType();
835 QualType promotionTypeRHS = getPromotionType(rhsTy);
839 if (!promotionTypeRHS.
isNull()) {
846 if (!promotionTypeRHS.
isNull()) {
850 opInfo.rhs = Visit(e->
getRHS());
859 mlir::Value lhsValue = emitLoadOfLValue(lhs, exprLoc);
860 QualType destTy = promotionTypeLHS.
isNull() ? opInfo.ty : promotionTypeLHS;
861 opInfo.lhs = emitComplexToComplexCast(lhsValue, lhsTy, destTy, exprLoc);
867 QualType promotedComplexElementTy;
868 if (!promotionTypeLHS.
isNull()) {
869 promotedComplexElementTy =
874 promotedComplexElementTy, exprLoc);
882 opInfo.lhs = emitScalarToComplexCast(lhsVal, lhsTy, opInfo.ty, exprLoc);
887 mlir::Value result = (this->*func)(opInfo);
891 mlir::Value resultValue =
892 emitComplexToComplexCast(result, opInfo.ty, lhsTy, exprLoc);
893 emitStoreOfComplex(loc, resultValue, lhs,
false);
896 mlir::Value resultValue =
905mlir::Value ComplexExprEmitter::emitCompoundAssign(
906 const CompoundAssignOperator *e,
907 mlir::Value (ComplexExprEmitter::*func)(
const BinOpInfo &)) {
909 LValue lv = emitCompoundAssignLValue(e, func, val);
916 if (!lv.isVolatileQualified())
922LValue ComplexExprEmitter::emitBinAssignLValue(
const BinaryOperator *e,
923 mlir::Value &value) {
926 "Invalid assignment");
929 value = Visit(e->
getRHS());
940mlir::Value ComplexExprEmitter::VisitBinAssign(
const BinaryOperator *e) {
942 LValue lv = emitBinAssignLValue(e, value);
950 if (!lv.isVolatile())
956mlir::Value ComplexExprEmitter::VisitBinComma(
const BinaryOperator *e) {
958 return Visit(e->
getRHS());
961mlir::Value ComplexExprEmitter::VisitAbstractConditionalOperator(
962 const AbstractConditionalOperator *e) {
966 CIRGenFunction::OpaqueValueMapping binding(cgf, e);
968 CIRGenFunction::ConditionalEvaluation eval(cgf);
974 .create<cir::TernaryOp>(
977 [&](mlir::OpBuilder &
b, mlir::Location loc) {
978 eval.beginEvaluation();
980 b.create<cir::YieldOp>(loc, trueValue);
981 eval.endEvaluation();
984 [&](mlir::OpBuilder &
b, mlir::Location loc) {
985 eval.beginEvaluation();
987 b.create<cir::YieldOp>(loc, falseValue);
988 eval.endEvaluation();
993mlir::Value ComplexExprEmitter::VisitChooseExpr(ChooseExpr *e) {
997mlir::Value ComplexExprEmitter::VisitInitListExpr(InitListExpr *e) {
1008 assert(e->
getNumInits() == 0 &&
"Unexpected number of inits");
1013mlir::Value ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *e) {
1025 "Invalid complex expression to emit");
1027 return ComplexExprEmitter(*this).Visit(
const_cast<Expr *
>(e));
1033 "Invalid complex expression to emit");
1034 ComplexExprEmitter emitter(*
this);
1035 mlir::Value value = emitter.Visit(
const_cast<Expr *
>(e));
1041 LValue dest,
bool isInit) {
1042 ComplexExprEmitter(*this).emitStoreOfComplex(loc, v, dest, isInit);
1046 return ComplexExprEmitter(*this).emitLoadOfLValue(src, loc);
1050 assert(e->
getOpcode() == BO_Assign &&
"Expected assign op");
1053 LValue lvalue = ComplexExprEmitter(*this).emitBinAssignLValue(e, value);
1055 cgm.errorNYI(
"emitComplexAssignmentLValue OpenMP");
1061 mlir::Value (ComplexExprEmitter::*)(
const ComplexExprEmitter::BinOpInfo &);
1066 return &ComplexExprEmitter::emitBinMul;
1068 return &ComplexExprEmitter::emitBinDiv;
1070 return &ComplexExprEmitter::emitBinSub;
1072 return &ComplexExprEmitter::emitBinAdd;
1074 llvm_unreachable(
"unexpected complex compound assignment");
1082 return ComplexExprEmitter(*this).emitCompoundAssignLValue(e, op, val);
1087 cir::UnaryOpKind op,
1089 assert(op == cir::UnaryOpKind::Inc ||
1090 op == cir::UnaryOpKind::Dec &&
"Invalid UnaryOp kind for ComplexType");
1094 mlir::Value incVal = builder.createUnaryOp(loc, op, inVal);
1100 cgm.errorNYI(loc,
"emitComplexPrePostIncDec OpenMP");
1104 return isPre ? incVal : inVal;
1113 LValue ret = ComplexExprEmitter(*this).emitCompoundAssignLValue(e, op, value);
static CompoundFunc getComplexOp(BinaryOperatorKind op)
static const ComplexType * getComplexType(QualType type)
Return the complex type that we are meant to emit.
mlir::Value(ComplexExprEmitter::*)(const ComplexExprEmitter::BinOpInfo &) CompoundFunc
static cir::ComplexRangeKind getComplexRangeAttr(LangOptions::ComplexRangeKind range)
__device__ __2f16 float __ockl_bool s
cir::ConstantOp getNullValue(mlir::Type ty, mlir::Location loc)
mlir::Value createCast(mlir::Location loc, cir::CastKind kind, mlir::Value src, mlir::Type newTy)
mlir::Value createAdd(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, OverflowBehavior ob=OverflowBehavior::None)
mlir::Value createNot(mlir::Value value)
mlir::Value createComplexImag(mlir::Location loc, mlir::Value operand)
mlir::Value createSub(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, OverflowBehavior ob=OverflowBehavior::Saturated)
mlir::Value createMul(mlir::Location loc, mlir::Value lhs, mlir::Value rhs, OverflowBehavior ob=OverflowBehavior::None)
mlir::Value createComplexCreate(mlir::Location loc, mlir::Value real, mlir::Value imag)
mlir::Value createUnaryOp(mlir::Location loc, cir::UnaryOpKind kind, mlir::Value operand)
mlir::Value createComplexReal(mlir::Location loc, mlir::Value operand)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Expr * getCond() const
getCond - Return the expression representing the condition for the ?
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
A builtin binary operation expression such as "x + y" or "x <= y".
SourceLocation getExprLoc() const
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
mlir::Value createFDiv(mlir::Location loc, mlir::Value lhs, mlir::Value rhs)
cir::LoadOp createLoad(mlir::Location loc, Address addr, bool isVolatile=false)
cir::StoreOp createStore(mlir::Location loc, mlir::Value val, Address dst, bool isVolatile=false, mlir::IntegerAttr align={}, cir::MemOrderAttr order={})
LValue getReferenceLValue(CIRGenFunction &cgf, Expr *refExpr) const
mlir::TypedAttr getValue() const
mlir::Value emitComplexToScalarConversion(mlir::Value src, QualType srcTy, QualType dstTy, SourceLocation loc)
Emit a conversion from the specified complex type to the specified destination type,...
mlir::Type convertType(clang::QualType t)
mlir::Value emitPromotedValue(mlir::Value result, QualType promotionType)
const clang::LangOptions & getLangOpts() const
LValue emitScalarCompoundAssignWithComplex(const CompoundAssignOperator *e, mlir::Value &result)
mlir::Value emitComplexExpr(const Expr *e)
Emit the computation of the specified expression of complex type, returning the result.
RValue emitCallExpr(const clang::CallExpr *e, ReturnValueSlot returnValue=ReturnValueSlot())
LValue emitLValue(const clang::Expr *e)
Emit code to compute a designator that specifies the location of the expression.
mlir::Value evaluateExprAsBool(const clang::Expr *e)
Perform the usual unary conversions on the specified expression and compare the result against zero,...
void emitStoreOfScalar(mlir::Value value, Address addr, bool isVolatile, clang::QualType ty, bool isInit=false, bool isNontemporal=false)
LValue emitComplexCompoundAssignmentLValue(const CompoundAssignOperator *e)
mlir::Location getLoc(clang::SourceLocation srcLoc)
Helpers to convert Clang's SourceLocation to a MLIR Location.
mlir::Value emitScalarConversion(mlir::Value src, clang::QualType srcType, clang::QualType dstType, clang::SourceLocation loc)
Emit a conversion from the specified type to the specified destination type, both of which are CIR sc...
mlir::Value emitPromotedComplexExpr(const Expr *e, QualType promotionType)
mlir::Value emitUnPromotedValue(mlir::Value result, QualType unPromotionType)
mlir::Type convertTypeForMem(QualType t)
mlir::Value emitLoadOfComplex(LValue src, SourceLocation loc)
Load a complex number from the specified l-value.
mlir::Value emitComplexPrePostIncDec(const UnaryOperator *e, LValue lv, cir::UnaryOpKind op, bool isPre)
void emitStoreOfComplex(mlir::Location loc, mlir::Value v, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
LValue emitComplexAssignmentLValue(const BinaryOperator *e)
mlir::Value emitScalarExpr(const clang::Expr *e)
Emit the computation of the specified expression of scalar type.
mlir::Value emitPromotedScalarExpr(const Expr *e, QualType promotionType)
mlir::Value emitLoadOfScalar(LValue lvalue, SourceLocation loc)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
void emitComplexExprIntoLValue(const Expr *e, LValue dest, bool isInit)
LValue makeAddrLValue(Address addr, QualType ty, AlignmentSource source=AlignmentSource::Type)
clang::ASTContext & getContext() const
bool isLValueSuitableForInlineAtomic(LValue lv)
An LValue is a candidate for having its loads and stores be made atomic if we are operating under /vo...
void emitIgnoredExpr(const clang::Expr *e)
Emit code to compute the specified expression, ignoring the result.
mlir::Value emitVAArg(VAArgExpr *ve)
Generate code to get an argument from the passed in pointer and update it accordingly.
DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef)
Helpers to emit "not yet implemented" error diagnostics.
This trivial value class is used to represent the result of an expression that is evaluated.
static RValue get(mlir::Value v)
static RValue getComplex(mlir::Value v)
mlir::Value getValue() const
Return the value of this scalar value.
mlir::Value getComplexValue() const
Return the value of this complex value.
SourceLocation getExprLoc() const
Expr * getExpr()
Get the initialization expression that will be used.
A rewritten comparison expression that was originally written using operator syntax.
SourceLocation getExprLoc() const LLVM_READONLY
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
CastKind getCastKind() const
bool changesVolatileQualification() const
Return.
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
QualType getComputationLHSType() const
QualType getComputationResultType() const
This represents one expression.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Expr * getResultExpr()
Return the result expression of this controlling expression.
const Expr * getSubExpr() const
unsigned getNumInits() const
const Expr * getInit(unsigned Init) const
ComplexRangeKind
Controls the various implementations for complex multiplication and.
@ CX_Full
Implementation of complex division and multiplication using a call to runtime library functions(gener...
@ CX_Basic
Implementation of complex division and multiplication using algebraic formulas at source precision.
@ CX_Promoted
Implementation of complex division using algebraic formulas at higher precision.
@ CX_None
No range rule is enabled.
@ CX_Improved
Implementation of complex division offering an improved handling for overflow in intermediate calcula...
SourceLocation getExprLoc() const LLVM_READONLY
const Expr * getSubExpr() const
SourceLocation getExprLoc() const LLVM_READONLY
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
bool UseExcessPrecision(const ASTContext &Ctx)
Encodes a location in the source.
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Expr * getReplacement() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isAnyComplexType() const
bool isRealFloatingType() const
Floating point categories.
bool isFloatingType() const
const T * getAs() const
Member-template getAs<specific type>'.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getExprLoc() const
Expr * getSubExpr() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The JSON file list parser is used to communicate input to InstallAPI.
CastKind
CastKind - The kind of operation required for a conversion.
U cast(CodeGen::Address addr)
static bool cgFPOptionsRAII()
static bool fastMathFlags()