1//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This contains code to emit Expr nodes with complex types as LLVM code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGDebugInfo.h"
14#include "CGOpenMPRuntime.h"
15#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
17#include "ConstantEmitter.h"
18#include "clang/AST/StmtVisitor.h"
19#include "llvm/IR/Constants.h"
20#include "llvm/IR/Instructions.h"
21#include "llvm/IR/MDBuilder.h"
22#include "llvm/IR/Metadata.h"
23using namespace clang;
24using namespace CodeGen;
25
26//===----------------------------------------------------------------------===//
27// Complex Expression Emitter
28//===----------------------------------------------------------------------===//
29
30typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
31
32/// Return the complex type that we are meant to emit.
33static const ComplexType *getComplexType(QualType type) {
34 type = type.getCanonicalType();
35 if (const ComplexType *comp = dyn_cast<ComplexType>(Val&: type)) {
36 return comp;
37 } else {
38 return cast<ComplexType>(Val: cast<AtomicType>(Val&: type)->getValueType());
39 }
40}
41
42namespace {
43class ComplexExprEmitter
44 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
45 CodeGenFunction &CGF;
46 CGBuilderTy &Builder;
47 bool IgnoreReal;
48 bool IgnoreImag;
49 bool FPHasBeenPromoted;
50
51public:
52 ComplexExprEmitter(CodeGenFunction &cgf, bool ir = false, bool ii = false)
53 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii),
54 FPHasBeenPromoted(false) {}
55
56 //===--------------------------------------------------------------------===//
57 // Utilities
58 //===--------------------------------------------------------------------===//
59
60 bool TestAndClearIgnoreReal() {
61 bool I = IgnoreReal;
62 IgnoreReal = false;
63 return I;
64 }
65 bool TestAndClearIgnoreImag() {
66 bool I = IgnoreImag;
67 IgnoreImag = false;
68 return I;
69 }
70
71 /// EmitLoadOfLValue - Given an expression with complex type that represents a
72 /// value l-value, this method emits the address of the l-value, then loads
73 /// and returns the result.
74 ComplexPairTy EmitLoadOfLValue(const Expr *E) {
75 return EmitLoadOfLValue(LV: CGF.EmitLValue(E), Loc: E->getExprLoc());
76 }
77
78 ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc);
79
80 /// EmitStoreOfComplex - Store the specified real/imag parts into the
81 /// specified value pointer.
82 void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit);
83
84 /// Emit a cast from complex value Val to DestType.
85 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
86 QualType DestType, SourceLocation Loc);
87 /// Emit a cast from scalar value Val to DestType.
88 ComplexPairTy EmitScalarToComplexCast(llvm::Value *Val, QualType SrcType,
89 QualType DestType, SourceLocation Loc);
90
91 //===--------------------------------------------------------------------===//
92 // Visitor Methods
93 //===--------------------------------------------------------------------===//
94
95 ComplexPairTy Visit(Expr *E) {
96 ApplyDebugLocation DL(CGF, E);
97 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(S: E);
98 }
99
100 ComplexPairTy VisitStmt(Stmt *S) {
101 S->dump(OS&: llvm::errs(), Context: CGF.getContext());
102 llvm_unreachable("Stmt can't have complex result type!");
103 }
104 ComplexPairTy VisitExpr(Expr *S);
105 ComplexPairTy VisitConstantExpr(ConstantExpr *E) {
106 if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(CE: E))
107 return ComplexPairTy(Result->getAggregateElement(Elt: 0U),
108 Result->getAggregateElement(Elt: 1U));
109 return Visit(E: E->getSubExpr());
110 }
111 ComplexPairTy VisitParenExpr(ParenExpr *PE) {
112 return Visit(E: PE->getSubExpr());
113 }
114 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
115 return Visit(E: GE->getResultExpr());
116 }
117 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
118 ComplexPairTy
119 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
120 return Visit(E: PE->getReplacement());
121 }
122 ComplexPairTy VisitCoawaitExpr(CoawaitExpr *S) {
123 return CGF.EmitCoawaitExpr(E: *S).getComplexVal();
124 }
125 ComplexPairTy VisitCoyieldExpr(CoyieldExpr *S) {
126 return CGF.EmitCoyieldExpr(E: *S).getComplexVal();
127 }
128 ComplexPairTy VisitUnaryCoawait(const UnaryOperator *E) {
129 return Visit(E: E->getSubExpr());
130 }
131
132 ComplexPairTy emitConstant(const CodeGenFunction::ConstantEmission &Constant,
133 Expr *E) {
134 assert(Constant && "not a constant");
135 if (Constant.isReference())
136 return EmitLoadOfLValue(LV: Constant.getReferenceLValue(CGF, RefExpr: E),
137 Loc: E->getExprLoc());
138
139 llvm::Constant *pair = Constant.getValue();
140 return ComplexPairTy(pair->getAggregateElement(Elt: 0U),
141 pair->getAggregateElement(Elt: 1U));
142 }
143
144 // l-values.
145 ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) {
146 if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(RefExpr: E))
147 return emitConstant(Constant, E);
148 return EmitLoadOfLValue(E);
149 }
150 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
151 return EmitLoadOfLValue(E);
152 }
153 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
154 return CGF.EmitObjCMessageExpr(E).getComplexVal();
155 }
156 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
157 ComplexPairTy VisitMemberExpr(MemberExpr *ME) {
158 if (CodeGenFunction::ConstantEmission Constant =
159 CGF.tryEmitAsConstant(ME)) {
160 CGF.EmitIgnoredExpr(E: ME->getBase());
161 return emitConstant(Constant, E: ME);
162 }
163 return EmitLoadOfLValue(E: ME);
164 }
165 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
166 if (E->isGLValue())
167 return EmitLoadOfLValue(LV: CGF.getOrCreateOpaqueLValueMapping(e: E),
168 Loc: E->getExprLoc());
169 return CGF.getOrCreateOpaqueRValueMapping(e: E).getComplexVal();
170 }
171
172 ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) {
173 return CGF.EmitPseudoObjectRValue(e: E).getComplexVal();
174 }
175
176 // FIXME: CompoundLiteralExpr
177
178 ComplexPairTy EmitCast(CastKind CK, Expr *Op, QualType DestTy);
179 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
180 // Unlike for scalars, we don't have to worry about function->ptr demotion
181 // here.
182 if (E->changesVolatileQualification())
183 return EmitLoadOfLValue(E);
184 return EmitCast(CK: E->getCastKind(), Op: E->getSubExpr(), DestTy: E->getType());
185 }
186 ComplexPairTy VisitCastExpr(CastExpr *E) {
187 if (const auto *ECE = dyn_cast<ExplicitCastExpr>(Val: E))
188 CGF.CGM.EmitExplicitCastExprType(E: ECE, CGF: &CGF);
189 if (E->changesVolatileQualification())
190 return EmitLoadOfLValue(E);
191 return EmitCast(CK: E->getCastKind(), Op: E->getSubExpr(), DestTy: E->getType());
192 }
193 ComplexPairTy VisitCallExpr(const CallExpr *E);
194 ComplexPairTy VisitStmtExpr(const StmtExpr *E);
195
196 // Operators.
197 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, bool isInc,
198 bool isPre) {
199 LValue LV = CGF.EmitLValue(E: E->getSubExpr());
200 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
201 }
202 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
203 return VisitPrePostIncDec(E, isInc: false, isPre: false);
204 }
205 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
206 return VisitPrePostIncDec(E, isInc: true, isPre: false);
207 }
208 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
209 return VisitPrePostIncDec(E, isInc: false, isPre: true);
210 }
211 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
212 return VisitPrePostIncDec(E, isInc: true, isPre: true);
213 }
214 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
215
216 ComplexPairTy VisitUnaryPlus(const UnaryOperator *E,
217 QualType PromotionType = QualType());
218 ComplexPairTy VisitPlus(const UnaryOperator *E, QualType PromotionType);
219 ComplexPairTy VisitUnaryMinus(const UnaryOperator *E,
220 QualType PromotionType = QualType());
221 ComplexPairTy VisitMinus(const UnaryOperator *E, QualType PromotionType);
222 ComplexPairTy VisitUnaryNot(const UnaryOperator *E);
223 // LNot,Real,Imag never return complex.
224 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
225 return Visit(E: E->getSubExpr());
226 }
227 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
228 CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
229 return Visit(E: DAE->getExpr());
230 }
231 ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
232 CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
233 return Visit(E: DIE->getExpr());
234 }
235 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
236 CodeGenFunction::RunCleanupsScope Scope(CGF);
237 ComplexPairTy Vals = Visit(E: E->getSubExpr());
238 // Defend against dominance problems caused by jumps out of expression
239 // evaluation through the shared cleanup block.
240 Scope.ForceCleanup(ValuesToReload: {&Vals.first, &Vals.second});
241 return Vals;
242 }
243 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
244 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
245 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
246 llvm::Constant *Null = llvm::Constant::getNullValue(Ty: CGF.ConvertType(T: Elem));
247 return ComplexPairTy(Null, Null);
248 }
249 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
250 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
251 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
252 llvm::Constant *Null = llvm::Constant::getNullValue(Ty: CGF.ConvertType(T: Elem));
253 return ComplexPairTy(Null, Null);
254 }
255
256 struct BinOpInfo {
257 ComplexPairTy LHS;
258 ComplexPairTy RHS;
259 QualType Ty; // Computation Type.
260 FPOptions FPFeatures;
261 };
262
263 BinOpInfo EmitBinOps(const BinaryOperator *E,
264 QualType PromotionTy = QualType());
265 ComplexPairTy EmitPromoted(const Expr *E, QualType PromotionTy);
266 ComplexPairTy EmitPromotedComplexOperand(const Expr *E, QualType PromotionTy);
267 LValue EmitCompoundAssignLValue(
268 const CompoundAssignOperator *E,
269 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &),
270 RValue &Val);
271 ComplexPairTy EmitCompoundAssign(
272 const CompoundAssignOperator *E,
273 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &));
274
275 ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
276 ComplexPairTy EmitBinSub(const BinOpInfo &Op);
277 ComplexPairTy EmitBinMul(const BinOpInfo &Op);
278 ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
279 ComplexPairTy EmitAlgebraicDiv(llvm::Value *A, llvm::Value *B, llvm::Value *C,
280 llvm::Value *D);
281 ComplexPairTy EmitRangeReductionDiv(llvm::Value *A, llvm::Value *B,
282 llvm::Value *C, llvm::Value *D);
283
284 ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName,
285 const BinOpInfo &Op);
286
287 QualType HigherPrecisionTypeForComplexArithmetic(QualType ElementType) {
288 ASTContext &Ctx = CGF.getContext();
289 const QualType HigherElementType =
290 Ctx.GetHigherPrecisionFPType(ElementType);
291 const llvm::fltSemantics &ElementTypeSemantics =
292 Ctx.getFloatTypeSemantics(T: ElementType);
293 const llvm::fltSemantics &HigherElementTypeSemantics =
294 Ctx.getFloatTypeSemantics(T: HigherElementType);
295 // Check that the promoted type can handle the intermediate values without
296 // overflowing. This can be interpreted as:
297 // (SmallerType.LargestFiniteVal * SmallerType.LargestFiniteVal) * 2 <=
298 // LargerType.LargestFiniteVal.
299 // In terms of exponent it gives this formula:
300 // (SmallerType.LargestFiniteVal * SmallerType.LargestFiniteVal
301 // doubles the exponent of SmallerType.LargestFiniteVal)
302 if (llvm::APFloat::semanticsMaxExponent(ElementTypeSemantics) * 2 + 1 <=
303 llvm::APFloat::semanticsMaxExponent(HigherElementTypeSemantics)) {
304 if (!Ctx.getTargetInfo().hasLongDoubleType() &&
305 HigherElementType.getCanonicalType().getUnqualifiedType() ==
306 Ctx.LongDoubleTy)
307 return QualType();
308 FPHasBeenPromoted = true;
309 return Ctx.getComplexType(T: HigherElementType);
310 } else {
311 // The intermediate values can't be represented in the promoted type
312 // without overflowing.
313 return QualType();
314 }
315 }
316
317 QualType getPromotionType(FPOptionsOverride Features, QualType Ty,
318 bool IsComplexDivisor) {
319 if (auto *CT = Ty->getAs<ComplexType>()) {
320 QualType ElementType = CT->getElementType().getCanonicalType();
321 bool IsFloatingType = ElementType->isFloatingType();
322 bool IsComplexRangePromoted = CGF.getLangOpts().getComplexRange() ==
323 LangOptions::ComplexRangeKind::CX_Promoted;
324 bool HasNoComplexRangeOverride = !Features.hasComplexRangeOverride();
325 bool HasMatchingComplexRange = Features.hasComplexRangeOverride() &&
326 Features.getComplexRangeOverride() ==
327 CGF.getLangOpts().getComplexRange();
328
329 if (IsComplexDivisor && IsFloatingType && IsComplexRangePromoted &&
330 (HasNoComplexRangeOverride || HasMatchingComplexRange))
331 return HigherPrecisionTypeForComplexArithmetic(ElementType);
332 if (ElementType.UseExcessPrecision(Ctx: CGF.getContext()))
333 return CGF.getContext().getComplexType(T: CGF.getContext().FloatTy);
334 }
335 if (Ty.UseExcessPrecision(Ctx: CGF.getContext()))
336 return CGF.getContext().FloatTy;
337 return QualType();
338 }
339
340#define HANDLEBINOP(OP) \
341 ComplexPairTy VisitBin##OP(const BinaryOperator *E) { \
342 QualType promotionTy = \
343 getPromotionType(E->getStoredFPFeaturesOrDefault(), E->getType(), \
344 (E->getOpcode() == BinaryOperatorKind::BO_Div && \
345 E->getRHS()->getType()->isAnyComplexType())); \
346 ComplexPairTy result = EmitBin##OP(EmitBinOps(E, promotionTy)); \
347 if (!promotionTy.isNull()) \
348 result = CGF.EmitUnPromotedValue(result, E->getType()); \
349 return result; \
350 }
351
352 HANDLEBINOP(Mul)
353 HANDLEBINOP(Div)
354 HANDLEBINOP(Add)
355 HANDLEBINOP(Sub)
356#undef HANDLEBINOP
357
358 ComplexPairTy VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
359 return Visit(E: E->getSemanticForm());
360 }
361
362 // Compound assignments.
363 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
364 ApplyAtomGroup Grp(CGF.getDebugInfo());
365 return EmitCompoundAssign(E, Func: &ComplexExprEmitter::EmitBinAdd);
366 }
367 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
368 ApplyAtomGroup Grp(CGF.getDebugInfo());
369 return EmitCompoundAssign(E, Func: &ComplexExprEmitter::EmitBinSub);
370 }
371 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
372 ApplyAtomGroup Grp(CGF.getDebugInfo());
373 return EmitCompoundAssign(E, Func: &ComplexExprEmitter::EmitBinMul);
374 }
375 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
376 ApplyAtomGroup Grp(CGF.getDebugInfo());
377 return EmitCompoundAssign(E, Func: &ComplexExprEmitter::EmitBinDiv);
378 }
379
380 // GCC rejects rem/and/or/xor for integer complex.
381 // Logical and/or always return int, never complex.
382
383 // No comparisons produce a complex result.
384
385 LValue EmitBinAssignLValue(const BinaryOperator *E, ComplexPairTy &Val);
386 ComplexPairTy VisitBinAssign(const BinaryOperator *E);
387 ComplexPairTy VisitBinComma(const BinaryOperator *E);
388
389 ComplexPairTy
390 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
391 ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
392
393 ComplexPairTy VisitInitListExpr(InitListExpr *E);
394
395 ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
396 return EmitLoadOfLValue(E);
397 }
398
399 ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
400
401 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
402 return CGF.EmitAtomicExpr(E).getComplexVal();
403 }
404
405 ComplexPairTy VisitPackIndexingExpr(PackIndexingExpr *E) {
406 return Visit(E: E->getSelectedExpr());
407 }
408};
409} // end anonymous namespace.
410
411//===----------------------------------------------------------------------===//
412// Utilities
413//===----------------------------------------------------------------------===//
414
415Address CodeGenFunction::emitAddrOfRealComponent(Address addr,
416 QualType complexType) {
417 return Builder.CreateStructGEP(Addr: addr, Index: 0, Name: addr.getName() + ".realp");
418}
419
420Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
421 QualType complexType) {
422 return Builder.CreateStructGEP(Addr: addr, Index: 1, Name: addr.getName() + ".imagp");
423}
424
425/// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to
426/// load the real and imaginary pieces, returning them as Real/Imag.
427ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue,
428 SourceLocation loc) {
429 assert(lvalue.isSimple() && "non-simple complex l-value?");
430 if (lvalue.getType()->isAtomicType())
431 return CGF.EmitAtomicLoad(LV: lvalue, SL: loc).getComplexVal();
432
433 Address SrcPtr = lvalue.getAddress();
434 bool isVolatile = lvalue.isVolatileQualified();
435
436 QualType ElemTy = getComplexType(type: lvalue.getType())->getElementType();
437 TBAAAccessInfo TBAAInfo = CGF.CGM.getTBAAInfoForSubobject(Base: lvalue, AccessType: ElemTy);
438
439 llvm::LoadInst *Real = nullptr, *Imag = nullptr;
440
441 if (!IgnoreReal || isVolatile) {
442 Address RealP = CGF.emitAddrOfRealComponent(addr: SrcPtr, complexType: lvalue.getType());
443 Real = Builder.CreateLoad(Addr: RealP, IsVolatile: isVolatile, Name: SrcPtr.getName() + ".real");
444 CGF.CGM.DecorateInstructionWithTBAA(Inst: Real, TBAAInfo);
445 }
446
447 if (!IgnoreImag || isVolatile) {
448 Address ImagP = CGF.emitAddrOfImagComponent(addr: SrcPtr, complexType: lvalue.getType());
449 Imag = Builder.CreateLoad(Addr: ImagP, IsVolatile: isVolatile, Name: SrcPtr.getName() + ".imag");
450 CGF.CGM.DecorateInstructionWithTBAA(Inst: Imag, TBAAInfo);
451 }
452
453 return ComplexPairTy(Real, Imag);
454}
455
456/// EmitStoreOfComplex - Store the specified real/imag parts into the
457/// specified value pointer.
458void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, LValue lvalue,
459 bool isInit) {
460 if (lvalue.getType()->isAtomicType() ||
461 (!isInit && CGF.LValueIsSuitableForInlineAtomic(Src: lvalue)))
462 return CGF.EmitAtomicStore(rvalue: RValue::getComplex(C: Val), lvalue, isInit);
463
464 Address Ptr = lvalue.getAddress();
465 Address RealPtr = CGF.emitAddrOfRealComponent(addr: Ptr, complexType: lvalue.getType());
466 Address ImagPtr = CGF.emitAddrOfImagComponent(addr: Ptr, complexType: lvalue.getType());
467
468 QualType ElemTy = getComplexType(type: lvalue.getType())->getElementType();
469 TBAAAccessInfo TBAAInfo = CGF.CGM.getTBAAInfoForSubobject(Base: lvalue, AccessType: ElemTy);
470
471 auto *R =
472 Builder.CreateStore(Val: Val.first, Addr: RealPtr, IsVolatile: lvalue.isVolatileQualified());
473 CGF.CGM.DecorateInstructionWithTBAA(Inst: R, TBAAInfo);
474 CGF.addInstToCurrentSourceAtom(KeyInstruction: R, Backup: Val.first);
475 auto *I =
476 Builder.CreateStore(Val: Val.second, Addr: ImagPtr, IsVolatile: lvalue.isVolatileQualified());
477 CGF.CGM.DecorateInstructionWithTBAA(Inst: I, TBAAInfo);
478 CGF.addInstToCurrentSourceAtom(KeyInstruction: I, Backup: Val.second);
479}
480
481//===----------------------------------------------------------------------===//
482// Visitor Methods
483//===----------------------------------------------------------------------===//
484
485ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
486 CGF.ErrorUnsupported(S: E, Type: "complex expression");
487 llvm::Type *EltTy =
488 CGF.ConvertType(T: getComplexType(type: E->getType())->getElementType());
489 llvm::Value *U = llvm::PoisonValue::get(T: EltTy);
490 return ComplexPairTy(U, U);
491}
492
493ComplexPairTy
494ComplexExprEmitter::VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
495 llvm::Value *Imag = CGF.EmitScalarExpr(E: IL->getSubExpr());
496 return ComplexPairTy(llvm::Constant::getNullValue(Ty: Imag->getType()), Imag);
497}
498
499ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
500 if (E->getCallReturnType(Ctx: CGF.getContext())->isReferenceType())
501 return EmitLoadOfLValue(E);
502
503 return CGF.EmitCallExpr(E).getComplexVal();
504}
505
506ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
507 CodeGenFunction::StmtExprEvaluation eval(CGF);
508 Address RetAlloca = CGF.EmitCompoundStmt(S: *E->getSubStmt(), GetLast: true);
509 assert(RetAlloca.isValid() && "Expected complex return value");
510 return EmitLoadOfLValue(lvalue: CGF.MakeAddrLValue(Addr: RetAlloca, T: E->getType()),
511 loc: E->getExprLoc());
512}
513
514/// Emit a cast from complex value Val to DestType.
515ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
516 QualType SrcType,
517 QualType DestType,
518 SourceLocation Loc) {
519 // Get the src/dest element type.
520 SrcType = SrcType.getAtomicUnqualifiedType()
521 ->castAs<ComplexType>()
522 ->getElementType();
523 DestType = DestType.getAtomicUnqualifiedType()
524 ->castAs<ComplexType>()
525 ->getElementType();
526
527 // C99 6.3.1.6: When a value of complex type is converted to another
528 // complex type, both the real and imaginary parts follow the conversion
529 // rules for the corresponding real types.
530 if (Val.first)
531 Val.first = CGF.EmitScalarConversion(Src: Val.first, SrcTy: SrcType, DstTy: DestType, Loc);
532 if (Val.second)
533 Val.second = CGF.EmitScalarConversion(Src: Val.second, SrcTy: SrcType, DstTy: DestType, Loc);
534 return Val;
535}
536
537ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val,
538 QualType SrcType,
539 QualType DestType,
540 SourceLocation Loc) {
541 // Convert the input element to the element type of the complex.
542 DestType = DestType->castAs<ComplexType>()->getElementType();
543 Val = CGF.EmitScalarConversion(Src: Val, SrcTy: SrcType, DstTy: DestType, Loc);
544
545 // Return (realval, 0).
546 return ComplexPairTy(Val, llvm::Constant::getNullValue(Ty: Val->getType()));
547}
548
549ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
550 QualType DestTy) {
551 DestTy = DestTy.getAtomicUnqualifiedType();
552 switch (CK) {
553 case CK_Dependent:
554 llvm_unreachable("dependent cast kind in IR gen!");
555
556 // Atomic to non-atomic casts may be more than a no-op for some platforms and
557 // for some types.
558 case CK_AtomicToNonAtomic:
559 case CK_NonAtomicToAtomic:
560 case CK_NoOp:
561 case CK_LValueToRValue:
562 case CK_UserDefinedConversion:
563 return Visit(E: Op);
564
565 case CK_LValueBitCast: {
566 LValue origLV = CGF.EmitLValue(E: Op);
567 Address V = origLV.getAddress().withElementType(ElemTy: CGF.ConvertType(T: DestTy));
568 return EmitLoadOfLValue(lvalue: CGF.MakeAddrLValue(Addr: V, T: DestTy), loc: Op->getExprLoc());
569 }
570
571 case CK_LValueToRValueBitCast: {
572 LValue SourceLVal = CGF.EmitLValue(E: Op);
573 Address Addr =
574 SourceLVal.getAddress().withElementType(ElemTy: CGF.ConvertTypeForMem(T: DestTy));
575 LValue DestLV = CGF.MakeAddrLValue(Addr, T: DestTy);
576 DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
577 return EmitLoadOfLValue(lvalue: DestLV, loc: Op->getExprLoc());
578 }
579
580 case CK_BitCast:
581 case CK_BaseToDerived:
582 case CK_DerivedToBase:
583 case CK_UncheckedDerivedToBase:
584 case CK_Dynamic:
585 case CK_ToUnion:
586 case CK_ArrayToPointerDecay:
587 case CK_FunctionToPointerDecay:
588 case CK_NullToPointer:
589 case CK_NullToMemberPointer:
590 case CK_BaseToDerivedMemberPointer:
591 case CK_DerivedToBaseMemberPointer:
592 case CK_MemberPointerToBoolean:
593 case CK_ReinterpretMemberPointer:
594 case CK_ConstructorConversion:
595 case CK_IntegralToPointer:
596 case CK_PointerToIntegral:
597 case CK_PointerToBoolean:
598 case CK_ToVoid:
599 case CK_VectorSplat:
600 case CK_IntegralCast:
601 case CK_BooleanToSignedIntegral:
602 case CK_IntegralToBoolean:
603 case CK_IntegralToFloating:
604 case CK_FloatingToIntegral:
605 case CK_FloatingToBoolean:
606 case CK_FloatingCast:
607 case CK_CPointerToObjCPointerCast:
608 case CK_BlockPointerToObjCPointerCast:
609 case CK_AnyPointerToBlockPointerCast:
610 case CK_ObjCObjectLValueCast:
611 case CK_FloatingComplexToReal:
612 case CK_FloatingComplexToBoolean:
613 case CK_IntegralComplexToReal:
614 case CK_IntegralComplexToBoolean:
615 case CK_ARCProduceObject:
616 case CK_ARCConsumeObject:
617 case CK_ARCReclaimReturnedObject:
618 case CK_ARCExtendBlockObject:
619 case CK_CopyAndAutoreleaseBlockObject:
620 case CK_BuiltinFnToFnPtr:
621 case CK_ZeroToOCLOpaqueType:
622 case CK_AddressSpaceConversion:
623 case CK_IntToOCLSampler:
624 case CK_FloatingToFixedPoint:
625 case CK_FixedPointToFloating:
626 case CK_FixedPointCast:
627 case CK_FixedPointToBoolean:
628 case CK_FixedPointToIntegral:
629 case CK_IntegralToFixedPoint:
630 case CK_MatrixCast:
631 case CK_HLSLVectorTruncation:
632 case CK_HLSLMatrixTruncation:
633 case CK_HLSLArrayRValue:
634 case CK_HLSLElementwiseCast:
635 case CK_HLSLAggregateSplatCast:
636 llvm_unreachable("invalid cast kind for complex value");
637
638 case CK_FloatingRealToComplex:
639 case CK_IntegralRealToComplex: {
640 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
641 return EmitScalarToComplexCast(Val: CGF.EmitScalarExpr(E: Op), SrcType: Op->getType(),
642 DestType: DestTy, Loc: Op->getExprLoc());
643 }
644
645 case CK_FloatingComplexCast:
646 case CK_FloatingComplexToIntegralComplex:
647 case CK_IntegralComplexCast:
648 case CK_IntegralComplexToFloatingComplex: {
649 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
650 return EmitComplexToComplexCast(Val: Visit(E: Op), SrcType: Op->getType(), DestType: DestTy,
651 Loc: Op->getExprLoc());
652 }
653 }
654
655 llvm_unreachable("unknown cast resulting in complex value");
656}
657
658ComplexPairTy ComplexExprEmitter::VisitUnaryPlus(const UnaryOperator *E,
659 QualType PromotionType) {
660 QualType promotionTy =
661 PromotionType.isNull()
662 ? getPromotionType(Features: E->getStoredFPFeaturesOrDefault(),
663 Ty: E->getSubExpr()->getType(),
664 /*IsComplexDivisor=*/false)
665 : PromotionType;
666 ComplexPairTy result = VisitPlus(E, PromotionType: promotionTy);
667 if (!promotionTy.isNull())
668 return CGF.EmitUnPromotedValue(result, PromotionType: E->getSubExpr()->getType());
669 return result;
670}
671
672ComplexPairTy ComplexExprEmitter::VisitPlus(const UnaryOperator *E,
673 QualType PromotionType) {
674 TestAndClearIgnoreReal();
675 TestAndClearIgnoreImag();
676 if (!PromotionType.isNull())
677 return CGF.EmitPromotedComplexExpr(E: E->getSubExpr(), PromotionType);
678 return Visit(E: E->getSubExpr());
679}
680
681ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E,
682 QualType PromotionType) {
683 QualType promotionTy =
684 PromotionType.isNull()
685 ? getPromotionType(Features: E->getStoredFPFeaturesOrDefault(),
686 Ty: E->getSubExpr()->getType(),
687 /*IsComplexDivisor=*/false)
688 : PromotionType;
689 ComplexPairTy result = VisitMinus(E, PromotionType: promotionTy);
690 if (!promotionTy.isNull())
691 return CGF.EmitUnPromotedValue(result, PromotionType: E->getSubExpr()->getType());
692 return result;
693}
694ComplexPairTy ComplexExprEmitter::VisitMinus(const UnaryOperator *E,
695 QualType PromotionType) {
696 TestAndClearIgnoreReal();
697 TestAndClearIgnoreImag();
698 ComplexPairTy Op;
699 if (!PromotionType.isNull())
700 Op = CGF.EmitPromotedComplexExpr(E: E->getSubExpr(), PromotionType);
701 else
702 Op = Visit(E: E->getSubExpr());
703
704 llvm::Value *ResR, *ResI;
705 if (Op.first->getType()->isFloatingPointTy()) {
706 ResR = Builder.CreateFNeg(V: Op.first, Name: "neg.r");
707 ResI = Builder.CreateFNeg(V: Op.second, Name: "neg.i");
708 } else {
709 ResR = Builder.CreateNeg(V: Op.first, Name: "neg.r");
710 ResI = Builder.CreateNeg(V: Op.second, Name: "neg.i");
711 }
712 return ComplexPairTy(ResR, ResI);
713}
714
715ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
716 TestAndClearIgnoreReal();
717 TestAndClearIgnoreImag();
718 // ~(a+ib) = a + i*-b
719 ComplexPairTy Op = Visit(E: E->getSubExpr());
720 llvm::Value *ResI;
721 if (Op.second->getType()->isFloatingPointTy())
722 ResI = Builder.CreateFNeg(V: Op.second, Name: "conj.i");
723 else
724 ResI = Builder.CreateNeg(V: Op.second, Name: "conj.i");
725
726 return ComplexPairTy(Op.first, ResI);
727}
728
729ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
730 llvm::Value *ResR, *ResI;
731
732 if (Op.LHS.first->getType()->isFloatingPointTy()) {
733 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
734 ResR = Builder.CreateFAdd(L: Op.LHS.first, R: Op.RHS.first, Name: "add.r");
735 if (Op.LHS.second && Op.RHS.second)
736 ResI = Builder.CreateFAdd(L: Op.LHS.second, R: Op.RHS.second, Name: "add.i");
737 else
738 ResI = Op.LHS.second ? Op.LHS.second : Op.RHS.second;
739 assert(ResI && "Only one operand may be real!");
740 } else {
741 ResR = Builder.CreateAdd(LHS: Op.LHS.first, RHS: Op.RHS.first, Name: "add.r");
742 assert(Op.LHS.second && Op.RHS.second &&
743 "Both operands of integer complex operators must be complex!");
744 ResI = Builder.CreateAdd(LHS: Op.LHS.second, RHS: Op.RHS.second, Name: "add.i");
745 }
746 return ComplexPairTy(ResR, ResI);
747}
748
749ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
750 llvm::Value *ResR, *ResI;
751 if (Op.LHS.first->getType()->isFloatingPointTy()) {
752 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
753 ResR = Builder.CreateFSub(L: Op.LHS.first, R: Op.RHS.first, Name: "sub.r");
754 if (Op.LHS.second && Op.RHS.second)
755 ResI = Builder.CreateFSub(L: Op.LHS.second, R: Op.RHS.second, Name: "sub.i");
756 else
757 ResI = Op.LHS.second ? Op.LHS.second
758 : Builder.CreateFNeg(V: Op.RHS.second, Name: "sub.i");
759 assert(ResI && "Only one operand may be real!");
760 } else {
761 ResR = Builder.CreateSub(LHS: Op.LHS.first, RHS: Op.RHS.first, Name: "sub.r");
762 assert(Op.LHS.second && Op.RHS.second &&
763 "Both operands of integer complex operators must be complex!");
764 ResI = Builder.CreateSub(LHS: Op.LHS.second, RHS: Op.RHS.second, Name: "sub.i");
765 }
766 return ComplexPairTy(ResR, ResI);
767}
768
769/// Emit a libcall for a binary operation on complex types.
770ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName,
771 const BinOpInfo &Op) {
772 CallArgList Args;
773 Args.add(rvalue: RValue::get(V: Op.LHS.first),
774 type: Op.Ty->castAs<ComplexType>()->getElementType());
775 Args.add(rvalue: RValue::get(V: Op.LHS.second),
776 type: Op.Ty->castAs<ComplexType>()->getElementType());
777 Args.add(rvalue: RValue::get(V: Op.RHS.first),
778 type: Op.Ty->castAs<ComplexType>()->getElementType());
779 Args.add(rvalue: RValue::get(V: Op.RHS.second),
780 type: Op.Ty->castAs<ComplexType>()->getElementType());
781
782 // We *must* use the full CG function call building logic here because the
783 // complex type has special ABI handling. We also should not forget about
784 // special calling convention which may be used for compiler builtins.
785
786 // We create a function qualified type to state that this call does not have
787 // any exceptions.
788 FunctionProtoType::ExtProtoInfo EPI;
789 EPI = EPI.withExceptionSpec(
790 ESI: FunctionProtoType::ExceptionSpecInfo(EST_BasicNoexcept));
791 SmallVector<QualType, 4> ArgsQTys(
792 4, Op.Ty->castAs<ComplexType>()->getElementType());
793 QualType FQTy = CGF.getContext().getFunctionType(ResultTy: Op.Ty, Args: ArgsQTys, EPI);
794 const CGFunctionInfo &FuncInfo = CGF.CGM.getTypes().arrangeFreeFunctionCall(
795 Args, Ty: cast<FunctionType>(Val: FQTy.getTypePtr()), ChainCall: false,
796 ABIInfoFD: CGF.getCurrentFunctionDecl());
797
798 llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(Info: FuncInfo);
799 llvm::FunctionCallee Func = CGF.CGM.CreateRuntimeFunction(
800 Ty: FTy, Name: LibCallName, ExtraAttrs: llvm::AttributeList(), Local: true);
801 CGCallee Callee = CGCallee::forDirect(functionPtr: Func, abstractInfo: FQTy->getAs<FunctionProtoType>());
802
803 llvm::CallBase *Call;
804 RValue Res = CGF.EmitCall(CallInfo: FuncInfo, Callee, ReturnValue: ReturnValueSlot(), Args, CallOrInvoke: &Call);
805 Call->setCallingConv(CGF.CGM.getRuntimeCC());
806 return Res.getComplexVal();
807}
808
809/// Lookup the libcall name for a given floating point type complex
810/// multiply.
811static StringRef getComplexMultiplyLibCallName(const llvm::Triple &T,
812 llvm::Type *Ty) {
813 switch (Ty->getTypeID()) {
814 default:
815 llvm_unreachable("Unsupported floating point type!");
816 case llvm::Type::HalfTyID:
817 return "__mulhc3";
818 case llvm::Type::FloatTyID:
819 return "__mulsc3";
820 case llvm::Type::DoubleTyID:
821 return "__muldc3";
822 case llvm::Type::PPC_FP128TyID:
823 return "__multc3";
824 case llvm::Type::X86_FP80TyID:
825 return "__mulxc3";
826 case llvm::Type::FP128TyID:
827 return T.isPPC() ? "__mulkc3" : "__multc3";
828 }
829}
830
831// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
832// typed values.
833ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
834 using llvm::Value;
835 Value *ResR, *ResI;
836 llvm::MDBuilder MDHelper(CGF.getLLVMContext());
837
838 if (Op.LHS.first->getType()->isFloatingPointTy()) {
839 // The general formulation is:
840 // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c)
841 //
842 // But we can fold away components which would be zero due to a real
843 // operand according to C11 Annex G.5.1p2.
844
845 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
846 if (Op.LHS.second && Op.RHS.second) {
847 // If both operands are complex, emit the core math directly, and then
848 // test for NaNs. If we find NaNs in the result, we delegate to a libcall
849 // to carefully re-compute the correct infinity representation if
850 // possible. The expectation is that the presence of NaNs here is
851 // *extremely* rare, and so the cost of the libcall is almost irrelevant.
852 // This is good, because the libcall re-computes the core multiplication
853 // exactly the same as we do here and re-tests for NaNs in order to be
854 // a generic complex*complex libcall.
855
856 // First compute the four products.
857 Value *AC = Builder.CreateFMul(L: Op.LHS.first, R: Op.RHS.first, Name: "mul_ac");
858 Value *BD = Builder.CreateFMul(L: Op.LHS.second, R: Op.RHS.second, Name: "mul_bd");
859 Value *AD = Builder.CreateFMul(L: Op.LHS.first, R: Op.RHS.second, Name: "mul_ad");
860 Value *BC = Builder.CreateFMul(L: Op.LHS.second, R: Op.RHS.first, Name: "mul_bc");
861
862 // The real part is the difference of the first two, the imaginary part is
863 // the sum of the second.
864 ResR = Builder.CreateFSub(L: AC, R: BD, Name: "mul_r");
865 ResI = Builder.CreateFAdd(L: AD, R: BC, Name: "mul_i");
866
867 if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Basic ||
868 Op.FPFeatures.getComplexRange() == LangOptions::CX_Improved ||
869 Op.FPFeatures.getComplexRange() == LangOptions::CX_Promoted)
870 return ComplexPairTy(ResR, ResI);
871
872 // Emit the test for the real part becoming NaN and create a branch to
873 // handle it. We test for NaN by comparing the number to itself.
874 Value *IsRNaN = Builder.CreateFCmpUNO(LHS: ResR, RHS: ResR, Name: "isnan_cmp");
875 llvm::BasicBlock *ContBB = CGF.createBasicBlock(name: "complex_mul_cont");
876 llvm::BasicBlock *INaNBB = CGF.createBasicBlock(name: "complex_mul_imag_nan");
877 llvm::Instruction *Branch = Builder.CreateCondBr(Cond: IsRNaN, True: INaNBB, False: ContBB);
878 llvm::BasicBlock *OrigBB = Branch->getParent();
879
880 // Give hint that we very much don't expect to see NaNs.
881 llvm::MDNode *BrWeight = MDHelper.createUnlikelyBranchWeights();
882 Branch->setMetadata(KindID: llvm::LLVMContext::MD_prof, Node: BrWeight);
883
884 // Now test the imaginary part and create its branch.
885 CGF.EmitBlock(BB: INaNBB);
886 Value *IsINaN = Builder.CreateFCmpUNO(LHS: ResI, RHS: ResI, Name: "isnan_cmp");
887 llvm::BasicBlock *LibCallBB = CGF.createBasicBlock(name: "complex_mul_libcall");
888 Branch = Builder.CreateCondBr(Cond: IsINaN, True: LibCallBB, False: ContBB);
889 Branch->setMetadata(KindID: llvm::LLVMContext::MD_prof, Node: BrWeight);
890
891 // Now emit the libcall on this slowest of the slow paths.
892 CGF.EmitBlock(BB: LibCallBB);
893 Value *LibCallR, *LibCallI;
894 llvm::Triple Triple = CGF.getTarget().getTriple();
895 std::tie(args&: LibCallR, args&: LibCallI) = EmitComplexBinOpLibCall(
896 LibCallName: getComplexMultiplyLibCallName(T: Triple, Ty: Op.LHS.first->getType()), Op);
897 Builder.CreateBr(Dest: ContBB);
898
899 // Finally continue execution by phi-ing together the different
900 // computation paths.
901 CGF.EmitBlock(BB: ContBB);
902 llvm::PHINode *RealPHI =
903 Builder.CreatePHI(Ty: ResR->getType(), NumReservedValues: 3, Name: "real_mul_phi");
904 RealPHI->addIncoming(V: ResR, BB: OrigBB);
905 RealPHI->addIncoming(V: ResR, BB: INaNBB);
906 RealPHI->addIncoming(V: LibCallR, BB: LibCallBB);
907 llvm::PHINode *ImagPHI =
908 Builder.CreatePHI(Ty: ResI->getType(), NumReservedValues: 3, Name: "imag_mul_phi");
909 ImagPHI->addIncoming(V: ResI, BB: OrigBB);
910 ImagPHI->addIncoming(V: ResI, BB: INaNBB);
911 ImagPHI->addIncoming(V: LibCallI, BB: LibCallBB);
912 return ComplexPairTy(RealPHI, ImagPHI);
913 }
914 assert((Op.LHS.second || Op.RHS.second) &&
915 "At least one operand must be complex!");
916
917 // If either of the operands is a real rather than a complex, the
918 // imaginary component is ignored when computing the real component of the
919 // result.
920 ResR = Builder.CreateFMul(L: Op.LHS.first, R: Op.RHS.first, Name: "mul.rl");
921
922 ResI = Op.LHS.second
923 ? Builder.CreateFMul(L: Op.LHS.second, R: Op.RHS.first, Name: "mul.il")
924 : Builder.CreateFMul(L: Op.LHS.first, R: Op.RHS.second, Name: "mul.ir");
925 } else {
926 assert(Op.LHS.second && Op.RHS.second &&
927 "Both operands of integer complex operators must be complex!");
928 Value *ResRl = Builder.CreateMul(LHS: Op.LHS.first, RHS: Op.RHS.first, Name: "mul.rl");
929 Value *ResRr = Builder.CreateMul(LHS: Op.LHS.second, RHS: Op.RHS.second, Name: "mul.rr");
930 ResR = Builder.CreateSub(LHS: ResRl, RHS: ResRr, Name: "mul.r");
931
932 Value *ResIl = Builder.CreateMul(LHS: Op.LHS.second, RHS: Op.RHS.first, Name: "mul.il");
933 Value *ResIr = Builder.CreateMul(LHS: Op.LHS.first, RHS: Op.RHS.second, Name: "mul.ir");
934 ResI = Builder.CreateAdd(LHS: ResIl, RHS: ResIr, Name: "mul.i");
935 }
936 return ComplexPairTy(ResR, ResI);
937}
938
939ComplexPairTy ComplexExprEmitter::EmitAlgebraicDiv(llvm::Value *LHSr,
940 llvm::Value *LHSi,
941 llvm::Value *RHSr,
942 llvm::Value *RHSi) {
943 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
944 llvm::Value *DSTr, *DSTi;
945
946 llvm::Value *AC = Builder.CreateFMul(L: LHSr, R: RHSr); // a*c
947 llvm::Value *BD = Builder.CreateFMul(L: LHSi, R: RHSi); // b*d
948 llvm::Value *ACpBD = Builder.CreateFAdd(L: AC, R: BD); // ac+bd
949
950 llvm::Value *CC = Builder.CreateFMul(L: RHSr, R: RHSr); // c*c
951 llvm::Value *DD = Builder.CreateFMul(L: RHSi, R: RHSi); // d*d
952 llvm::Value *CCpDD = Builder.CreateFAdd(L: CC, R: DD); // cc+dd
953
954 llvm::Value *BC = Builder.CreateFMul(L: LHSi, R: RHSr); // b*c
955 llvm::Value *AD = Builder.CreateFMul(L: LHSr, R: RHSi); // a*d
956 llvm::Value *BCmAD = Builder.CreateFSub(L: BC, R: AD); // bc-ad
957
958 DSTr = Builder.CreateFDiv(L: ACpBD, R: CCpDD);
959 DSTi = Builder.CreateFDiv(L: BCmAD, R: CCpDD);
960 return ComplexPairTy(DSTr, DSTi);
961}
962
963// EmitFAbs - Emit a call to @llvm.fabs.
964static llvm::Value *EmitllvmFAbs(CodeGenFunction &CGF, llvm::Value *Value) {
965 return CGF.Builder.CreateFAbs(V: Value);
966}
967
968// EmitRangeReductionDiv - Implements Smith's algorithm for complex division.
969// SMITH, R. L. Algorithm 116: Complex division. Commun. ACM 5, 8 (1962).
970ComplexPairTy ComplexExprEmitter::EmitRangeReductionDiv(llvm::Value *LHSr,
971 llvm::Value *LHSi,
972 llvm::Value *RHSr,
973 llvm::Value *RHSi) {
974 // FIXME: This could eventually be replaced by an LLVM intrinsic to
975 // avoid this long IR sequence.
976
977 // (a + ib) / (c + id) = (e + if)
978 llvm::Value *FAbsRHSr = EmitllvmFAbs(CGF, Value: RHSr); // |c|
979 llvm::Value *FAbsRHSi = EmitllvmFAbs(CGF, Value: RHSi); // |d|
980 // |c| >= |d|
981 llvm::Value *IsR = Builder.CreateFCmpUGT(LHS: FAbsRHSr, RHS: FAbsRHSi, Name: "abs_cmp");
982
983 llvm::BasicBlock *TrueBB =
984 CGF.createBasicBlock(name: "abs_rhsr_greater_or_equal_abs_rhsi");
985 llvm::BasicBlock *FalseBB =
986 CGF.createBasicBlock(name: "abs_rhsr_less_than_abs_rhsi");
987 llvm::BasicBlock *ContBB = CGF.createBasicBlock(name: "complex_div");
988 Builder.CreateCondBr(Cond: IsR, True: TrueBB, False: FalseBB);
989
990 CGF.EmitBlock(BB: TrueBB);
991 // abs(c) >= abs(d)
992 // r = d/c
993 // tmp = c + rd
994 // e = (a + br)/tmp
995 // f = (b - ar)/tmp
996 llvm::Value *DdC = Builder.CreateFDiv(L: RHSi, R: RHSr); // r=d/c
997
998 llvm::Value *RD = Builder.CreateFMul(L: DdC, R: RHSi); // rd
999 llvm::Value *CpRD = Builder.CreateFAdd(L: RHSr, R: RD); // tmp=c+rd
1000
1001 llvm::Value *T3 = Builder.CreateFMul(L: LHSi, R: DdC); // br
1002 llvm::Value *T4 = Builder.CreateFAdd(L: LHSr, R: T3); // a+br
1003 llvm::Value *DSTTr = Builder.CreateFDiv(L: T4, R: CpRD); // (a+br)/tmp
1004
1005 llvm::Value *T5 = Builder.CreateFMul(L: LHSr, R: DdC); // ar
1006 llvm::Value *T6 = Builder.CreateFSub(L: LHSi, R: T5); // b-ar
1007 llvm::Value *DSTTi = Builder.CreateFDiv(L: T6, R: CpRD); // (b-ar)/tmp
1008 Builder.CreateBr(Dest: ContBB);
1009
1010 CGF.EmitBlock(BB: FalseBB);
1011 // abs(c) < abs(d)
1012 // r = c/d
1013 // tmp = d + rc
1014 // e = (ar + b)/tmp
1015 // f = (br - a)/tmp
1016 llvm::Value *CdD = Builder.CreateFDiv(L: RHSr, R: RHSi); // r=c/d
1017
1018 llvm::Value *RC = Builder.CreateFMul(L: CdD, R: RHSr); // rc
1019 llvm::Value *DpRC = Builder.CreateFAdd(L: RHSi, R: RC); // tmp=d+rc
1020
1021 llvm::Value *T7 = Builder.CreateFMul(L: LHSr, R: CdD); // ar
1022 llvm::Value *T8 = Builder.CreateFAdd(L: T7, R: LHSi); // ar+b
1023 llvm::Value *DSTFr = Builder.CreateFDiv(L: T8, R: DpRC); // (ar+b)/tmp
1024
1025 llvm::Value *T9 = Builder.CreateFMul(L: LHSi, R: CdD); // br
1026 llvm::Value *T10 = Builder.CreateFSub(L: T9, R: LHSr); // br-a
1027 llvm::Value *DSTFi = Builder.CreateFDiv(L: T10, R: DpRC); // (br-a)/tmp
1028 Builder.CreateBr(Dest: ContBB);
1029
1030 // Phi together the computation paths.
1031 CGF.EmitBlock(BB: ContBB);
1032 llvm::PHINode *VALr = Builder.CreatePHI(Ty: DSTTr->getType(), NumReservedValues: 2);
1033 VALr->addIncoming(V: DSTTr, BB: TrueBB);
1034 VALr->addIncoming(V: DSTFr, BB: FalseBB);
1035 llvm::PHINode *VALi = Builder.CreatePHI(Ty: DSTTi->getType(), NumReservedValues: 2);
1036 VALi->addIncoming(V: DSTTi, BB: TrueBB);
1037 VALi->addIncoming(V: DSTFi, BB: FalseBB);
1038 return ComplexPairTy(VALr, VALi);
1039}
1040
1041// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
1042// typed values.
1043ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
1044 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
1045 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
1046 llvm::Value *DSTr, *DSTi;
1047 if (LHSr->getType()->isFloatingPointTy()) {
1048 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
1049 if (!RHSi) {
1050 assert(LHSi && "Can have at most one non-complex operand!");
1051
1052 DSTr = Builder.CreateFDiv(L: LHSr, R: RHSr);
1053 DSTi = Builder.CreateFDiv(L: LHSi, R: RHSr);
1054 return ComplexPairTy(DSTr, DSTi);
1055 }
1056 llvm::Value *OrigLHSi = LHSi;
1057 if (!LHSi)
1058 LHSi = llvm::Constant::getNullValue(Ty: RHSi->getType());
1059 if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Improved ||
1060 (Op.FPFeatures.getComplexRange() == LangOptions::CX_Promoted &&
1061 !FPHasBeenPromoted))
1062 return EmitRangeReductionDiv(LHSr, LHSi, RHSr, RHSi);
1063 else if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Basic ||
1064 Op.FPFeatures.getComplexRange() == LangOptions::CX_Promoted)
1065 return EmitAlgebraicDiv(LHSr, LHSi, RHSr, RHSi);
1066 // '-ffast-math' is used in the command line but followed by an
1067 // '-fno-cx-limited-range' or '-fcomplex-arithmetic=full'.
1068 else if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Full) {
1069 LHSi = OrigLHSi;
1070 // If we have a complex operand on the RHS and FastMath is not allowed, we
1071 // delegate to a libcall to handle all of the complexities and minimize
1072 // underflow/overflow cases. When FastMath is allowed we construct the
1073 // divide inline using the same algorithm as for integer operands.
1074 BinOpInfo LibCallOp = Op;
1075 // If LHS was a real, supply a null imaginary part.
1076 if (!LHSi)
1077 LibCallOp.LHS.second = llvm::Constant::getNullValue(Ty: LHSr->getType());
1078
1079 switch (LHSr->getType()->getTypeID()) {
1080 default:
1081 llvm_unreachable("Unsupported floating point type!");
1082 case llvm::Type::HalfTyID:
1083 return EmitComplexBinOpLibCall(LibCallName: "__divhc3", Op: LibCallOp);
1084 case llvm::Type::FloatTyID:
1085 return EmitComplexBinOpLibCall(LibCallName: "__divsc3", Op: LibCallOp);
1086 case llvm::Type::DoubleTyID:
1087 return EmitComplexBinOpLibCall(LibCallName: "__divdc3", Op: LibCallOp);
1088 case llvm::Type::PPC_FP128TyID:
1089 return EmitComplexBinOpLibCall(LibCallName: "__divtc3", Op: LibCallOp);
1090 case llvm::Type::X86_FP80TyID:
1091 return EmitComplexBinOpLibCall(LibCallName: "__divxc3", Op: LibCallOp);
1092 case llvm::Type::FP128TyID:
1093 return EmitComplexBinOpLibCall(
1094 LibCallName: CGF.getTarget().getTriple().isPPC() ? "__divkc3" : "__divtc3",
1095 Op: LibCallOp);
1096 }
1097 } else {
1098 return EmitAlgebraicDiv(LHSr, LHSi, RHSr, RHSi);
1099 }
1100 } else {
1101 assert(Op.LHS.second && Op.RHS.second &&
1102 "Both operands of integer complex operators must be complex!");
1103 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
1104 llvm::Value *Tmp1 = Builder.CreateMul(LHS: LHSr, RHS: RHSr); // a*c
1105 llvm::Value *Tmp2 = Builder.CreateMul(LHS: LHSi, RHS: RHSi); // b*d
1106 llvm::Value *Tmp3 = Builder.CreateAdd(LHS: Tmp1, RHS: Tmp2); // ac+bd
1107
1108 llvm::Value *Tmp4 = Builder.CreateMul(LHS: RHSr, RHS: RHSr); // c*c
1109 llvm::Value *Tmp5 = Builder.CreateMul(LHS: RHSi, RHS: RHSi); // d*d
1110 llvm::Value *Tmp6 = Builder.CreateAdd(LHS: Tmp4, RHS: Tmp5); // cc+dd
1111
1112 llvm::Value *Tmp7 = Builder.CreateMul(LHS: LHSi, RHS: RHSr); // b*c
1113 llvm::Value *Tmp8 = Builder.CreateMul(LHS: LHSr, RHS: RHSi); // a*d
1114 llvm::Value *Tmp9 = Builder.CreateSub(LHS: Tmp7, RHS: Tmp8); // bc-ad
1115
1116 if (Op.Ty->castAs<ComplexType>()
1117 ->getElementType()
1118 ->isUnsignedIntegerType()) {
1119 DSTr = Builder.CreateUDiv(LHS: Tmp3, RHS: Tmp6);
1120 DSTi = Builder.CreateUDiv(LHS: Tmp9, RHS: Tmp6);
1121 } else {
1122 DSTr = Builder.CreateSDiv(LHS: Tmp3, RHS: Tmp6);
1123 DSTi = Builder.CreateSDiv(LHS: Tmp9, RHS: Tmp6);
1124 }
1125 }
1126
1127 return ComplexPairTy(DSTr, DSTi);
1128}
1129
1130ComplexPairTy CodeGenFunction::EmitUnPromotedValue(ComplexPairTy result,
1131 QualType UnPromotionType) {
1132 llvm::Type *ComplexElementTy =
1133 ConvertType(T: UnPromotionType->castAs<ComplexType>()->getElementType());
1134 if (result.first)
1135 result.first =
1136 Builder.CreateFPTrunc(V: result.first, DestTy: ComplexElementTy, Name: "unpromotion");
1137 if (result.second)
1138 result.second =
1139 Builder.CreateFPTrunc(V: result.second, DestTy: ComplexElementTy, Name: "unpromotion");
1140 return result;
1141}
1142
1143ComplexPairTy CodeGenFunction::EmitPromotedValue(ComplexPairTy result,
1144 QualType PromotionType) {
1145 llvm::Type *ComplexElementTy =
1146 ConvertType(T: PromotionType->castAs<ComplexType>()->getElementType());
1147 if (result.first)
1148 result.first = Builder.CreateFPExt(V: result.first, DestTy: ComplexElementTy, Name: "ext");
1149 if (result.second)
1150 result.second = Builder.CreateFPExt(V: result.second, DestTy: ComplexElementTy, Name: "ext");
1151
1152 return result;
1153}
1154
1155ComplexPairTy ComplexExprEmitter::EmitPromoted(const Expr *E,
1156 QualType PromotionType) {
1157 E = E->IgnoreParens();
1158 if (auto BO = dyn_cast<BinaryOperator>(Val: E)) {
1159 switch (BO->getOpcode()) {
1160#define HANDLE_BINOP(OP) \
1161 case BO_##OP: \
1162 return EmitBin##OP(EmitBinOps(BO, PromotionType));
1163 HANDLE_BINOP(Add)
1164 HANDLE_BINOP(Sub)
1165 HANDLE_BINOP(Mul)
1166 HANDLE_BINOP(Div)
1167#undef HANDLE_BINOP
1168 default:
1169 break;
1170 }
1171 } else if (auto UO = dyn_cast<UnaryOperator>(Val: E)) {
1172 switch (UO->getOpcode()) {
1173 case UO_Minus:
1174 return VisitMinus(E: UO, PromotionType);
1175 case UO_Plus:
1176 return VisitPlus(E: UO, PromotionType);
1177 default:
1178 break;
1179 }
1180 }
1181 auto result = Visit(E: const_cast<Expr *>(E));
1182 if (!PromotionType.isNull())
1183 return CGF.EmitPromotedValue(result, PromotionType);
1184 else
1185 return result;
1186}
1187
1188ComplexPairTy CodeGenFunction::EmitPromotedComplexExpr(const Expr *E,
1189 QualType DstTy) {
1190 return ComplexExprEmitter(*this).EmitPromoted(E, PromotionType: DstTy);
1191}
1192
1193ComplexPairTy
1194ComplexExprEmitter::EmitPromotedComplexOperand(const Expr *E,
1195 QualType OverallPromotionType) {
1196 if (E->getType()->isAnyComplexType()) {
1197 if (!OverallPromotionType.isNull())
1198 return CGF.EmitPromotedComplexExpr(E, DstTy: OverallPromotionType);
1199 else
1200 return Visit(E: const_cast<Expr *>(E));
1201 } else {
1202 if (!OverallPromotionType.isNull()) {
1203 QualType ComplexElementTy =
1204 OverallPromotionType->castAs<ComplexType>()->getElementType();
1205 return ComplexPairTy(CGF.EmitPromotedScalarExpr(E, PromotionType: ComplexElementTy),
1206 nullptr);
1207 } else {
1208 return ComplexPairTy(CGF.EmitScalarExpr(E), nullptr);
1209 }
1210 }
1211}
1212
1213ComplexExprEmitter::BinOpInfo
1214ComplexExprEmitter::EmitBinOps(const BinaryOperator *E,
1215 QualType PromotionType) {
1216 TestAndClearIgnoreReal();
1217 TestAndClearIgnoreImag();
1218 BinOpInfo Ops;
1219
1220 Ops.LHS = EmitPromotedComplexOperand(E: E->getLHS(), OverallPromotionType: PromotionType);
1221 Ops.RHS = EmitPromotedComplexOperand(E: E->getRHS(), OverallPromotionType: PromotionType);
1222 if (!PromotionType.isNull())
1223 Ops.Ty = PromotionType;
1224 else
1225 Ops.Ty = E->getType();
1226 Ops.FPFeatures = E->getFPFeaturesInEffect(LO: CGF.getLangOpts());
1227 return Ops;
1228}
1229
1230LValue ComplexExprEmitter::EmitCompoundAssignLValue(
1231 const CompoundAssignOperator *E,
1232 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &), RValue &Val) {
1233 TestAndClearIgnoreReal();
1234 TestAndClearIgnoreImag();
1235 QualType LHSTy = E->getLHS()->getType().getAtomicUnqualifiedType();
1236
1237 BinOpInfo OpInfo;
1238 OpInfo.FPFeatures = E->getFPFeaturesInEffect(LO: CGF.getLangOpts());
1239 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, OpInfo.FPFeatures);
1240
1241 const bool IsComplexDivisor = E->getOpcode() == BO_DivAssign &&
1242 E->getRHS()->getType()->isAnyComplexType();
1243
1244 // Load the RHS and LHS operands.
1245 // __block variables need to have the rhs evaluated first, plus this should
1246 // improve codegen a little.
1247 QualType PromotionTypeCR;
1248 PromotionTypeCR =
1249 getPromotionType(Features: E->getStoredFPFeaturesOrDefault(),
1250 Ty: E->getComputationResultType(), IsComplexDivisor);
1251 if (PromotionTypeCR.isNull())
1252 PromotionTypeCR = E->getComputationResultType();
1253 OpInfo.Ty = PromotionTypeCR;
1254 QualType ComplexElementTy =
1255 OpInfo.Ty->castAs<ComplexType>()->getElementType();
1256 QualType PromotionTypeRHS =
1257 getPromotionType(Features: E->getStoredFPFeaturesOrDefault(),
1258 Ty: E->getRHS()->getType(), IsComplexDivisor);
1259
1260 // The RHS should have been converted to the computation type.
1261 if (E->getRHS()->getType()->isRealFloatingType()) {
1262 if (!PromotionTypeRHS.isNull())
1263 OpInfo.RHS = ComplexPairTy(
1264 CGF.EmitPromotedScalarExpr(E: E->getRHS(), PromotionType: PromotionTypeRHS), nullptr);
1265 else {
1266 assert(CGF.getContext().hasSameUnqualifiedType(ComplexElementTy,
1267 E->getRHS()->getType()));
1268
1269 OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E: E->getRHS()), nullptr);
1270 }
1271 } else {
1272 if (!PromotionTypeRHS.isNull()) {
1273 OpInfo.RHS = ComplexPairTy(
1274 CGF.EmitPromotedComplexExpr(E: E->getRHS(), DstTy: PromotionTypeRHS));
1275 } else {
1276 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
1277 E->getRHS()->getType()));
1278 OpInfo.RHS = Visit(E: E->getRHS());
1279 }
1280 }
1281
1282 LValue LHS = CGF.EmitLValue(E: E->getLHS());
1283
1284 // Load from the l-value and convert it.
1285 SourceLocation Loc = E->getExprLoc();
1286 QualType PromotionTypeLHS =
1287 getPromotionType(Features: E->getStoredFPFeaturesOrDefault(),
1288 Ty: E->getComputationLHSType(), IsComplexDivisor);
1289 if (LHSTy->isAnyComplexType()) {
1290 ComplexPairTy LHSVal = EmitLoadOfLValue(lvalue: LHS, loc: Loc);
1291 if (!PromotionTypeLHS.isNull())
1292 OpInfo.LHS =
1293 EmitComplexToComplexCast(Val: LHSVal, SrcType: LHSTy, DestType: PromotionTypeLHS, Loc);
1294 else
1295 OpInfo.LHS = EmitComplexToComplexCast(Val: LHSVal, SrcType: LHSTy, DestType: OpInfo.Ty, Loc);
1296 } else {
1297 llvm::Value *LHSVal = CGF.EmitLoadOfLValue(V: LHS, Loc).getScalarVal();
1298 // For floating point real operands we can directly pass the scalar form
1299 // to the binary operator emission and potentially get more efficient code.
1300 if (LHSTy->isRealFloatingType()) {
1301 QualType PromotedComplexElementTy;
1302 if (!PromotionTypeLHS.isNull()) {
1303 PromotedComplexElementTy =
1304 cast<ComplexType>(Val&: PromotionTypeLHS)->getElementType();
1305 if (!CGF.getContext().hasSameUnqualifiedType(T1: PromotedComplexElementTy,
1306 T2: PromotionTypeLHS))
1307 LHSVal = CGF.EmitScalarConversion(Src: LHSVal, SrcTy: LHSTy,
1308 DstTy: PromotedComplexElementTy, Loc);
1309 } else {
1310 if (!CGF.getContext().hasSameUnqualifiedType(T1: ComplexElementTy, T2: LHSTy))
1311 LHSVal =
1312 CGF.EmitScalarConversion(Src: LHSVal, SrcTy: LHSTy, DstTy: ComplexElementTy, Loc);
1313 }
1314 OpInfo.LHS = ComplexPairTy(LHSVal, nullptr);
1315 } else {
1316 OpInfo.LHS = EmitScalarToComplexCast(Val: LHSVal, SrcType: LHSTy, DestType: OpInfo.Ty, Loc);
1317 }
1318 }
1319
1320 // Expand the binary operator.
1321 ComplexPairTy Result = (this->*Func)(OpInfo);
1322
1323 // Truncate the result and store it into the LHS lvalue.
1324 if (LHSTy->isAnyComplexType()) {
1325 ComplexPairTy ResVal =
1326 EmitComplexToComplexCast(Val: Result, SrcType: OpInfo.Ty, DestType: LHSTy, Loc);
1327 EmitStoreOfComplex(Val: ResVal, lvalue: LHS, /*isInit*/ false);
1328 Val = RValue::getComplex(C: ResVal);
1329 } else {
1330 llvm::Value *ResVal =
1331 CGF.EmitComplexToScalarConversion(Src: Result, SrcTy: OpInfo.Ty, DstTy: LHSTy, Loc);
1332 CGF.EmitStoreThroughLValue(Src: RValue::get(V: ResVal), Dst: LHS, /*isInit*/ false);
1333 Val = RValue::get(V: ResVal);
1334 }
1335
1336 return LHS;
1337}
1338
1339// Compound assignments.
1340ComplexPairTy ComplexExprEmitter::EmitCompoundAssign(
1341 const CompoundAssignOperator *E,
1342 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &)) {
1343 RValue Val;
1344 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
1345
1346 // The result of an assignment in C is the assigned r-value.
1347 if (!CGF.getLangOpts().CPlusPlus)
1348 return Val.getComplexVal();
1349
1350 // If the lvalue is non-volatile, return the computed value of the assignment.
1351 if (!LV.isVolatileQualified())
1352 return Val.getComplexVal();
1353
1354 return EmitLoadOfLValue(lvalue: LV, loc: E->getExprLoc());
1355}
1356
1357LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
1358 ComplexPairTy &Val) {
1359 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
1360 E->getRHS()->getType()) &&
1361 "Invalid assignment");
1362 TestAndClearIgnoreReal();
1363 TestAndClearIgnoreImag();
1364
1365 // Emit the RHS. __block variables need the RHS evaluated first.
1366 Val = Visit(E: E->getRHS());
1367
1368 // Compute the address to store into.
1369 LValue LHS = CGF.EmitLValue(E: E->getLHS());
1370
1371 // Store the result value into the LHS lvalue.
1372 EmitStoreOfComplex(Val, lvalue: LHS, /*isInit*/ false);
1373
1374 return LHS;
1375}
1376
1377ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
1378 ComplexPairTy Val;
1379 ApplyAtomGroup Grp(CGF.getDebugInfo());
1380 LValue LV = EmitBinAssignLValue(E, Val);
1381
1382 // The result of an assignment in C is the assigned r-value.
1383 if (!CGF.getLangOpts().CPlusPlus)
1384 return Val;
1385
1386 // If the lvalue is non-volatile, return the computed value of the assignment.
1387 if (!LV.isVolatileQualified())
1388 return Val;
1389
1390 return EmitLoadOfLValue(lvalue: LV, loc: E->getExprLoc());
1391}
1392
1393ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
1394 CGF.EmitIgnoredExpr(E: E->getLHS());
1395 return Visit(E: E->getRHS());
1396}
1397
1398ComplexPairTy ComplexExprEmitter::VisitAbstractConditionalOperator(
1399 const AbstractConditionalOperator *E) {
1400 TestAndClearIgnoreReal();
1401 TestAndClearIgnoreImag();
1402 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock(name: "cond.true");
1403 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock(name: "cond.false");
1404 llvm::BasicBlock *ContBlock = CGF.createBasicBlock(name: "cond.end");
1405
1406 // Bind the common expression if necessary.
1407 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1408
1409 CodeGenFunction::ConditionalEvaluation eval(CGF);
1410 CGF.EmitBranchOnBoolExpr(Cond: E->getCond(), TrueBlock: LHSBlock, FalseBlock: RHSBlock,
1411 TrueCount: CGF.getProfileCount(S: E));
1412
1413 eval.begin(CGF);
1414 CGF.EmitBlock(BB: LHSBlock);
1415 CGF.incrementProfileCounter(ExecSkip: CGF.UseExecPath, S: E);
1416 ComplexPairTy LHS = Visit(E: E->getTrueExpr());
1417 LHSBlock = Builder.GetInsertBlock();
1418 CGF.EmitBranch(Block: ContBlock);
1419 eval.end(CGF);
1420
1421 eval.begin(CGF);
1422 CGF.EmitBlock(BB: RHSBlock);
1423 CGF.incrementProfileCounter(ExecSkip: CGF.UseSkipPath, S: E);
1424 ComplexPairTy RHS = Visit(E: E->getFalseExpr());
1425 RHSBlock = Builder.GetInsertBlock();
1426 CGF.EmitBlock(BB: ContBlock);
1427 eval.end(CGF);
1428
1429 // Create a PHI node for the real part.
1430 llvm::PHINode *RealPN = Builder.CreatePHI(Ty: LHS.first->getType(), NumReservedValues: 2, Name: "cond.r");
1431 RealPN->addIncoming(V: LHS.first, BB: LHSBlock);
1432 RealPN->addIncoming(V: RHS.first, BB: RHSBlock);
1433
1434 // Create a PHI node for the imaginary part.
1435 llvm::PHINode *ImagPN = Builder.CreatePHI(Ty: LHS.first->getType(), NumReservedValues: 2, Name: "cond.i");
1436 ImagPN->addIncoming(V: LHS.second, BB: LHSBlock);
1437 ImagPN->addIncoming(V: RHS.second, BB: RHSBlock);
1438
1439 return ComplexPairTy(RealPN, ImagPN);
1440}
1441
1442ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
1443 return Visit(E: E->getChosenSubExpr());
1444}
1445
1446ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
1447 bool Ignore = TestAndClearIgnoreReal();
1448 (void)Ignore;
1449 assert(Ignore == false && "init list ignored");
1450 Ignore = TestAndClearIgnoreImag();
1451 (void)Ignore;
1452 assert(Ignore == false && "init list ignored");
1453
1454 if (E->getNumInits() == 2) {
1455 llvm::Value *Real = CGF.EmitScalarExpr(E: E->getInit(Init: 0));
1456 llvm::Value *Imag = CGF.EmitScalarExpr(E: E->getInit(Init: 1));
1457 return ComplexPairTy(Real, Imag);
1458 } else if (E->getNumInits() == 1) {
1459 return Visit(E: E->getInit(Init: 0));
1460 }
1461
1462 // Empty init list initializes to null
1463 assert(E->getNumInits() == 0 && "Unexpected number of inits");
1464 QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
1465 llvm::Type *LTy = CGF.ConvertType(T: Ty);
1466 llvm::Value *zeroConstant = llvm::Constant::getNullValue(Ty: LTy);
1467 return ComplexPairTy(zeroConstant, zeroConstant);
1468}
1469
1470ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
1471 Address ArgValue = Address::invalid();
1472 RValue RV = CGF.EmitVAArg(VE: E, VAListAddr&: ArgValue);
1473
1474 if (!ArgValue.isValid()) {
1475 CGF.ErrorUnsupported(S: E, Type: "complex va_arg expression");
1476 llvm::Type *EltTy =
1477 CGF.ConvertType(T: E->getType()->castAs<ComplexType>()->getElementType());
1478 llvm::Value *U = llvm::PoisonValue::get(T: EltTy);
1479 return ComplexPairTy(U, U);
1480 }
1481
1482 return RV.getComplexVal();
1483}
1484
1485//===----------------------------------------------------------------------===//
1486// Entry Point into this File
1487//===----------------------------------------------------------------------===//
1488
1489/// EmitComplexExpr - Emit the computation of the specified expression of
1490/// complex type, ignoring the result.
1491ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
1492 bool IgnoreImag) {
1493 assert(E && getComplexType(E->getType()) &&
1494 "Invalid complex expression to emit");
1495
1496 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
1497 .Visit(E: const_cast<Expr *>(E));
1498}
1499
1500void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
1501 bool isInit) {
1502 assert(E && getComplexType(E->getType()) &&
1503 "Invalid complex expression to emit");
1504 ComplexExprEmitter Emitter(*this);
1505 ComplexPairTy Val = Emitter.Visit(E: const_cast<Expr *>(E));
1506 Emitter.EmitStoreOfComplex(Val, lvalue: dest, isInit);
1507}
1508
1509/// EmitStoreOfComplex - Store a complex number into the specified l-value.
1510void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
1511 bool isInit) {
1512 ComplexExprEmitter(*this).EmitStoreOfComplex(Val: V, lvalue: dest, isInit);
1513}
1514
1515/// EmitLoadOfComplex - Load a complex number from the specified address.
1516ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src,
1517 SourceLocation loc) {
1518 return ComplexExprEmitter(*this).EmitLoadOfLValue(lvalue: src, loc);
1519}
1520
1521LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
1522 assert(E->getOpcode() == BO_Assign);
1523 ComplexPairTy Val; // ignored
1524 LValue LVal = ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
1525 if (getLangOpts().OpenMP)
1526 CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(CGF&: *this,
1527 LHS: E->getLHS());
1528 return LVal;
1529}
1530
1531typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)(
1532 const ComplexExprEmitter::BinOpInfo &);
1533
1534static CompoundFunc getComplexOp(BinaryOperatorKind Op) {
1535 switch (Op) {
1536 case BO_MulAssign:
1537 return &ComplexExprEmitter::EmitBinMul;
1538 case BO_DivAssign:
1539 return &ComplexExprEmitter::EmitBinDiv;
1540 case BO_SubAssign:
1541 return &ComplexExprEmitter::EmitBinSub;
1542 case BO_AddAssign:
1543 return &ComplexExprEmitter::EmitBinAdd;
1544 default:
1545 llvm_unreachable("unexpected complex compound assignment");
1546 }
1547}
1548
1549LValue CodeGenFunction::EmitComplexCompoundAssignmentLValue(
1550 const CompoundAssignOperator *E) {
1551 ApplyAtomGroup Grp(getDebugInfo());
1552 CompoundFunc Op = getComplexOp(Op: E->getOpcode());
1553 RValue Val;
1554 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Func: Op, Val);
1555}
1556
1557LValue CodeGenFunction::EmitScalarCompoundAssignWithComplex(
1558 const CompoundAssignOperator *E, llvm::Value *&Result) {
1559 // Key Instructions: Don't need to create an atom group here; one will already
1560 // be active through scalar handling code.
1561 CompoundFunc Op = getComplexOp(Op: E->getOpcode());
1562 RValue Val;
1563 LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Func: Op, Val);
1564 Result = Val.getScalarVal();
1565 return Ret;
1566}
1567