Coverage Report

Created: 2021-01-19 06:58

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGExprComplex.cpp
Line
Count
Source (jump to first uncovered line)
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 "CGOpenMPRuntime.h"
14
#include "CodeGenFunction.h"
15
#include "CodeGenModule.h"
16
#include "ConstantEmitter.h"
17
#include "clang/AST/StmtVisitor.h"
18
#include "llvm/ADT/STLExtras.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"
23
#include <algorithm>
24
using namespace clang;
25
using namespace CodeGen;
26
27
//===----------------------------------------------------------------------===//
28
//                        Complex Expression Emitter
29
//===----------------------------------------------------------------------===//
30
31
typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
32
33
/// Return the complex type that we are meant to emit.
34
2.00k
static const ComplexType *getComplexType(QualType type) {
35
2.00k
  type = type.getCanonicalType();
36
2.00k
  if (const ComplexType *comp = dyn_cast<ComplexType>(type)) {
37
1.99k
    return comp;
38
6
  } else {
39
6
    return cast<ComplexType>(cast<AtomicType>(type)->getValueType());
40
6
  }
41
2.00k
}
42
43
namespace  {
44
class ComplexExprEmitter
45
  : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
46
  CodeGenFunction &CGF;
47
  CGBuilderTy &Builder;
48
  bool IgnoreReal;
49
  bool IgnoreImag;
50
public:
51
  ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
52
3.53k
    : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
53
3.53k
  }
54
55
56
  //===--------------------------------------------------------------------===//
57
  //                               Utilities
58
  //===--------------------------------------------------------------------===//
59
60
933
  bool TestAndClearIgnoreReal() {
61
933
    bool I = IgnoreReal;
62
933
    IgnoreReal = false;
63
933
    return I;
64
933
  }
65
933
  bool TestAndClearIgnoreImag() {
66
933
    bool I = IgnoreImag;
67
933
    IgnoreImag = false;
68
933
    return I;
69
933
  }
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
1.17k
  ComplexPairTy EmitLoadOfLValue(const Expr *E) {
75
1.17k
    return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc());
76
1.17k
  }
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
4.70k
  ComplexPairTy Visit(Expr *E) {
96
4.70k
    ApplyDebugLocation DL(CGF, E);
97
4.70k
    return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
98
4.70k
  }
99
100
0
  ComplexPairTy VisitStmt(Stmt *S) {
101
0
    S->dump(llvm::errs(), CGF.getContext());
102
0
    llvm_unreachable("Stmt can't have complex result type!");
103
0
  }
104
  ComplexPairTy VisitExpr(Expr *S);
105
0
  ComplexPairTy VisitConstantExpr(ConstantExpr *E) {
106
0
    if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E))
107
0
      return ComplexPairTy(Result->getAggregateElement(0U),
108
0
                           Result->getAggregateElement(1U));
109
0
    return Visit(E->getSubExpr());
110
0
  }
111
94
  ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
112
0
  ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
113
0
    return Visit(GE->getResultExpr());
114
0
  }
115
  ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
116
  ComplexPairTy
117
2
  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
118
2
    return Visit(PE->getReplacement());
119
2
  }
120
3
  ComplexPairTy VisitCoawaitExpr(CoawaitExpr *S) {
121
3
    return CGF.EmitCoawaitExpr(*S).getComplexVal();
122
3
  }
123
0
  ComplexPairTy VisitCoyieldExpr(CoyieldExpr *S) {
124
0
    return CGF.EmitCoyieldExpr(*S).getComplexVal();
125
0
  }
126
0
  ComplexPairTy VisitUnaryCoawait(const UnaryOperator *E) {
127
0
    return Visit(E->getSubExpr());
128
0
  }
129
130
  ComplexPairTy emitConstant(const CodeGenFunction::ConstantEmission &Constant,
131
9
                             Expr *E) {
132
9
    assert(Constant && "not a constant");
133
9
    if (Constant.isReference())
134
1
      return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E),
135
1
                              E->getExprLoc());
136
137
8
    llvm::Constant *pair = Constant.getValue();
138
8
    return ComplexPairTy(pair->getAggregateElement(0U),
139
8
                         pair->getAggregateElement(1U));
140
8
  }
141
142
  // l-values.
143
1.14k
  ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) {
144
1.14k
    if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
145
4
      return emitConstant(Constant, E);
146
1.13k
    return EmitLoadOfLValue(E);
147
1.13k
  }
148
12
  ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
149
12
    return EmitLoadOfLValue(E);
150
12
  }
151
16
  ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
152
16
    return CGF.EmitObjCMessageExpr(E).getComplexVal();
153
16
  }
154
4
  ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
155
9
  ComplexPairTy VisitMemberExpr(MemberExpr *ME) {
156
9
    if (CodeGenFunction::ConstantEmission Constant =
157
5
            CGF.tryEmitAsConstant(ME)) {
158
5
      CGF.EmitIgnoredExpr(ME->getBase());
159
5
      return emitConstant(Constant, ME);
160
5
    }
161
4
    return EmitLoadOfLValue(ME);
162
4
  }
163
69
  ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
164
69
    if (E->isGLValue())
165
3
      return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
166
3
                              E->getExprLoc());
167
66
    return CGF.getOrCreateOpaqueRValueMapping(E).getComplexVal();
168
66
  }
169
170
15
  ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) {
171
15
    return CGF.EmitPseudoObjectRValue(E).getComplexVal();
172
15
  }
173
174
  // FIXME: CompoundLiteralExpr
175
176
  ComplexPairTy EmitCast(CastKind CK, Expr *Op, QualType DestTy);
177
1.98k
  ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
178
    // Unlike for scalars, we don't have to worry about function->ptr demotion
179
    // here.
180
1.98k
    return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
181
1.98k
  }
182
16
  ComplexPairTy VisitCastExpr(CastExpr *E) {
183
16
    if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
184
16
      CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
185
16
    return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
186
16
  }
187
  ComplexPairTy VisitCallExpr(const CallExpr *E);
188
  ComplexPairTy VisitStmtExpr(const StmtExpr *E);
189
190
  // Operators.
191
  ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
192
8
                                   bool isInc, bool isPre) {
193
8
    LValue LV = CGF.EmitLValue(E->getSubExpr());
194
8
    return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
195
8
  }
196
2
  ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
197
2
    return VisitPrePostIncDec(E, false, false);
198
2
  }
199
2
  ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
200
2
    return VisitPrePostIncDec(E, true, false);
201
2
  }
202
2
  ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
203
2
    return VisitPrePostIncDec(E, false, true);
204
2
  }
205
2
  ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
206
2
    return VisitPrePostIncDec(E, true, true);
207
2
  }
208
8
  ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
209
5
  ComplexPairTy VisitUnaryPlus     (const UnaryOperator *E) {
210
5
    TestAndClearIgnoreReal();
211
5
    TestAndClearIgnoreImag();
212
5
    return Visit(E->getSubExpr());
213
5
  }
214
  ComplexPairTy VisitUnaryMinus    (const UnaryOperator *E);
215
  ComplexPairTy VisitUnaryNot      (const UnaryOperator *E);
216
  // LNot,Real,Imag never return complex.
217
18
  ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
218
18
    return Visit(E->getSubExpr());
219
18
  }
220
9
  ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
221
9
    CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
222
9
    return Visit(DAE->getExpr());
223
9
  }
224
0
  ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
225
0
    CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
226
0
    return Visit(DIE->getExpr());
227
0
  }
228
3
  ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
229
3
    CodeGenFunction::RunCleanupsScope Scope(CGF);
230
3
    ComplexPairTy Vals = Visit(E->getSubExpr());
231
    // Defend against dominance problems caused by jumps out of expression
232
    // evaluation through the shared cleanup block.
233
3
    Scope.ForceCleanup({&Vals.first, &Vals.second});
234
3
    return Vals;
235
3
  }
236
2
  ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
237
2
    assert(E->getType()->isAnyComplexType() && "Expected complex type!");
238
2
    QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
239
2
    llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
240
2
    return ComplexPairTy(Null, Null);
241
2
  }
242
1
  ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
243
1
    assert(E->getType()->isAnyComplexType() && "Expected complex type!");
244
1
    QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
245
1
    llvm::Constant *Null =
246
1
                       llvm::Constant::getNullValue(CGF.ConvertType(Elem));
247
1
    return ComplexPairTy(Null, Null);
248
1
  }
249
250
  struct BinOpInfo {
251
    ComplexPairTy LHS;
252
    ComplexPairTy RHS;
253
    QualType Ty;  // Computation Type.
254
  };
255
256
  BinOpInfo EmitBinOps(const BinaryOperator *E);
257
  LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
258
                                  ComplexPairTy (ComplexExprEmitter::*Func)
259
                                  (const BinOpInfo &),
260
                                  RValue &Val);
261
  ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
262
                                   ComplexPairTy (ComplexExprEmitter::*Func)
263
                                   (const BinOpInfo &));
264
265
  ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
266
  ComplexPairTy EmitBinSub(const BinOpInfo &Op);
267
  ComplexPairTy EmitBinMul(const BinOpInfo &Op);
268
  ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
269
270
  ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName,
271
                                        const BinOpInfo &Op);
272
273
232
  ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
274
232
    return EmitBinAdd(EmitBinOps(E));
275
232
  }
276
138
  ComplexPairTy VisitBinSub(const BinaryOperator *E) {
277
138
    return EmitBinSub(EmitBinOps(E));
278
138
  }
279
131
  ComplexPairTy VisitBinMul(const BinaryOperator *E) {
280
131
    return EmitBinMul(EmitBinOps(E));
281
131
  }
282
106
  ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
283
106
    return EmitBinDiv(EmitBinOps(E));
284
106
  }
285
286
0
  ComplexPairTy VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
287
0
    return Visit(E->getSemanticForm());
288
0
  }
289
290
  // Compound assignments.
291
9
  ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
292
9
    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
293
9
  }
294
0
  ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
295
0
    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
296
0
  }
297
1
  ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
298
1
    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
299
1
  }
300
5
  ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
301
5
    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
302
5
  }
303
304
  // GCC rejects rem/and/or/xor for integer complex.
305
  // Logical and/or always return int, never complex.
306
307
  // No comparisons produce a complex result.
308
309
  LValue EmitBinAssignLValue(const BinaryOperator *E,
310
                             ComplexPairTy &Val);
311
  ComplexPairTy VisitBinAssign     (const BinaryOperator *E);
312
  ComplexPairTy VisitBinComma      (const BinaryOperator *E);
313
314
315
  ComplexPairTy
316
  VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
317
  ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
318
319
  ComplexPairTy VisitInitListExpr(InitListExpr *E);
320
321
1
  ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
322
1
    return EmitLoadOfLValue(E);
323
1
  }
324
325
  ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
326
327
4
  ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
328
4
    return CGF.EmitAtomicExpr(E).getComplexVal();
329
4
  }
330
};
331
}  // end anonymous namespace.
332
333
//===----------------------------------------------------------------------===//
334
//                                Utilities
335
//===----------------------------------------------------------------------===//
336
337
Address CodeGenFunction::emitAddrOfRealComponent(Address addr,
338
3.77k
                                                 QualType complexType) {
339
3.77k
  return Builder.CreateStructGEP(addr, 0, addr.getName() + ".realp");
340
3.77k
}
341
342
Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
343
3.75k
                                                 QualType complexType) {
344
3.75k
  return Builder.CreateStructGEP(addr, 1, addr.getName() + ".imagp");
345
3.75k
}
346
347
/// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to
348
/// load the real and imaginary pieces, returning them as Real/Imag.
349
ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue,
350
1.83k
                                                   SourceLocation loc) {
351
1.83k
  assert(lvalue.isSimple() && "non-simple complex l-value?");
352
1.83k
  if (lvalue.getType()->isAtomicType())
353
4
    return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal();
354
355
1.83k
  Address SrcPtr = lvalue.getAddress(CGF);
356
1.83k
  bool isVolatile = lvalue.isVolatileQualified();
357
358
1.83k
  llvm::Value *Real = nullptr, *Imag = nullptr;
359
360
1.83k
  if (!IgnoreReal || 
isVolatile9
) {
361
1.83k
    Address RealP = CGF.emitAddrOfRealComponent(SrcPtr, lvalue.getType());
362
1.83k
    Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr.getName() + ".real");
363
1.83k
  }
364
365
1.83k
  if (!IgnoreImag || 
isVolatile45
) {
366
1.80k
    Address ImagP = CGF.emitAddrOfImagComponent(SrcPtr, lvalue.getType());
367
1.80k
    Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr.getName() + ".imag");
368
1.80k
  }
369
370
1.83k
  return ComplexPairTy(Real, Imag);
371
1.83k
}
372
373
/// EmitStoreOfComplex - Store the specified real/imag parts into the
374
/// specified value pointer.
375
void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, LValue lvalue,
376
1.84k
                                            bool isInit) {
377
1.84k
  if (lvalue.getType()->isAtomicType() ||
378
1.84k
      (!isInit && 
CGF.LValueIsSuitableForInlineAtomic(lvalue)324
))
379
6
    return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit);
380
381
1.84k
  Address Ptr = lvalue.getAddress(CGF);
382
1.84k
  Address RealPtr = CGF.emitAddrOfRealComponent(Ptr, lvalue.getType());
383
1.84k
  Address ImagPtr = CGF.emitAddrOfImagComponent(Ptr, lvalue.getType());
384
385
1.84k
  Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified());
386
1.84k
  Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified());
387
1.84k
}
388
389
390
391
//===----------------------------------------------------------------------===//
392
//                            Visitor Methods
393
//===----------------------------------------------------------------------===//
394
395
0
ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
396
0
  CGF.ErrorUnsupported(E, "complex expression");
397
0
  llvm::Type *EltTy =
398
0
    CGF.ConvertType(getComplexType(E->getType())->getElementType());
399
0
  llvm::Value *U = llvm::UndefValue::get(EltTy);
400
0
  return ComplexPairTy(U, U);
401
0
}
402
403
ComplexPairTy ComplexExprEmitter::
404
121
VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
405
121
  llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
406
121
  return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
407
121
}
408
409
410
309
ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
411
309
  if (E->getCallReturnType(CGF.getContext())->isReferenceType())
412
2
    return EmitLoadOfLValue(E);
413
414
307
  return CGF.EmitCallExpr(E).getComplexVal();
415
307
}
416
417
0
ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
418
0
  CodeGenFunction::StmtExprEvaluation eval(CGF);
419
0
  Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true);
420
0
  assert(RetAlloca.isValid() && "Expected complex return value");
421
0
  return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()),
422
0
                          E->getExprLoc());
423
0
}
424
425
/// Emit a cast from complex value Val to DestType.
426
ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
427
                                                           QualType SrcType,
428
                                                           QualType DestType,
429
304
                                                           SourceLocation Loc) {
430
  // Get the src/dest element type.
431
304
  SrcType = SrcType->castAs<ComplexType>()->getElementType();
432
304
  DestType = DestType->castAs<ComplexType>()->getElementType();
433
434
  // C99 6.3.1.6: When a value of complex type is converted to another
435
  // complex type, both the real and imaginary parts follow the conversion
436
  // rules for the corresponding real types.
437
304
  if (Val.first)
438
303
    Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType, Loc);
439
304
  if (Val.second)
440
303
    Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType, Loc);
441
304
  return Val;
442
304
}
443
444
ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val,
445
                                                          QualType SrcType,
446
                                                          QualType DestType,
447
640
                                                          SourceLocation Loc) {
448
  // Convert the input element to the element type of the complex.
449
640
  DestType = DestType->castAs<ComplexType>()->getElementType();
450
640
  Val = CGF.EmitScalarConversion(Val, SrcType, DestType, Loc);
451
452
  // Return (realval, 0).
453
640
  return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType()));
454
640
}
455
456
ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
457
1.99k
                                           QualType DestTy) {
458
1.99k
  switch (CK) {
459
0
  case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
460
461
  // Atomic to non-atomic casts may be more than a no-op for some platforms and
462
  // for some types.
463
2
  case CK_AtomicToNonAtomic:
464
6
  case CK_NonAtomicToAtomic:
465
6
  case CK_NoOp:
466
1.20k
  case CK_LValueToRValue:
467
1.20k
  case CK_UserDefinedConversion:
468
1.20k
    return Visit(Op);
469
470
9
  case CK_LValueBitCast: {
471
9
    LValue origLV = CGF.EmitLValue(Op);
472
9
    Address V = origLV.getAddress(CGF);
473
9
    V = Builder.CreateElementBitCast(V, CGF.ConvertType(DestTy));
474
9
    return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), Op->getExprLoc());
475
1.20k
  }
476
477
1
  case CK_LValueToRValueBitCast: {
478
1
    LValue SourceLVal = CGF.EmitLValue(Op);
479
1
    Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(CGF),
480
1
                                                CGF.ConvertTypeForMem(DestTy));
481
1
    LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
482
1
    DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
483
1
    return EmitLoadOfLValue(DestLV, Op->getExprLoc());
484
1.20k
  }
485
486
0
  case CK_BitCast:
487
0
  case CK_BaseToDerived:
488
0
  case CK_DerivedToBase:
489
0
  case CK_UncheckedDerivedToBase:
490
0
  case CK_Dynamic:
491
0
  case CK_ToUnion:
492
0
  case CK_ArrayToPointerDecay:
493
0
  case CK_FunctionToPointerDecay:
494
0
  case CK_NullToPointer:
495
0
  case CK_NullToMemberPointer:
496
0
  case CK_BaseToDerivedMemberPointer:
497
0
  case CK_DerivedToBaseMemberPointer:
498
0
  case CK_MemberPointerToBoolean:
499
0
  case CK_ReinterpretMemberPointer:
500
0
  case CK_ConstructorConversion:
501
0
  case CK_IntegralToPointer:
502
0
  case CK_PointerToIntegral:
503
0
  case CK_PointerToBoolean:
504
0
  case CK_ToVoid:
505
0
  case CK_VectorSplat:
506
0
  case CK_IntegralCast:
507
0
  case CK_BooleanToSignedIntegral:
508
0
  case CK_IntegralToBoolean:
509
0
  case CK_IntegralToFloating:
510
0
  case CK_FloatingToIntegral:
511
0
  case CK_FloatingToBoolean:
512
0
  case CK_FloatingCast:
513
0
  case CK_CPointerToObjCPointerCast:
514
0
  case CK_BlockPointerToObjCPointerCast:
515
0
  case CK_AnyPointerToBlockPointerCast:
516
0
  case CK_ObjCObjectLValueCast:
517
0
  case CK_FloatingComplexToReal:
518
0
  case CK_FloatingComplexToBoolean:
519
0
  case CK_IntegralComplexToReal:
520
0
  case CK_IntegralComplexToBoolean:
521
0
  case CK_ARCProduceObject:
522
0
  case CK_ARCConsumeObject:
523
0
  case CK_ARCReclaimReturnedObject:
524
0
  case CK_ARCExtendBlockObject:
525
0
  case CK_CopyAndAutoreleaseBlockObject:
526
0
  case CK_BuiltinFnToFnPtr:
527
0
  case CK_ZeroToOCLOpaqueType:
528
0
  case CK_AddressSpaceConversion:
529
0
  case CK_IntToOCLSampler:
530
0
  case CK_FloatingToFixedPoint:
531
0
  case CK_FixedPointToFloating:
532
0
  case CK_FixedPointCast:
533
0
  case CK_FixedPointToBoolean:
534
0
  case CK_FixedPointToIntegral:
535
0
  case CK_IntegralToFixedPoint:
536
0
    llvm_unreachable("invalid cast kind for complex value");
537
538
522
  case CK_FloatingRealToComplex:
539
639
  case CK_IntegralRealToComplex: {
540
639
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
541
639
    return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(),
542
639
                                   DestTy, Op->getExprLoc());
543
522
  }
544
545
49
  case CK_FloatingComplexCast:
546
71
  case CK_FloatingComplexToIntegralComplex:
547
135
  case CK_IntegralComplexCast:
548
146
  case CK_IntegralComplexToFloatingComplex: {
549
146
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
550
146
    return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy,
551
146
                                    Op->getExprLoc());
552
0
  }
553
0
  }
554
555
0
  llvm_unreachable("unknown cast resulting in complex value");
556
0
}
557
558
3
ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
559
3
  TestAndClearIgnoreReal();
560
3
  TestAndClearIgnoreImag();
561
3
  ComplexPairTy Op = Visit(E->getSubExpr());
562
563
3
  llvm::Value *ResR, *ResI;
564
3
  if (Op.first->getType()->isFloatingPointTy()) {
565
2
    ResR = Builder.CreateFNeg(Op.first,  "neg.r");
566
2
    ResI = Builder.CreateFNeg(Op.second, "neg.i");
567
1
  } else {
568
1
    ResR = Builder.CreateNeg(Op.first,  "neg.r");
569
1
    ResI = Builder.CreateNeg(Op.second, "neg.i");
570
1
  }
571
3
  return ComplexPairTy(ResR, ResI);
572
3
}
573
574
3
ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
575
3
  TestAndClearIgnoreReal();
576
3
  TestAndClearIgnoreImag();
577
  // ~(a+ib) = a + i*-b
578
3
  ComplexPairTy Op = Visit(E->getSubExpr());
579
3
  llvm::Value *ResI;
580
3
  if (Op.second->getType()->isFloatingPointTy())
581
2
    ResI = Builder.CreateFNeg(Op.second, "conj.i");
582
1
  else
583
1
    ResI = Builder.CreateNeg(Op.second, "conj.i");
584
585
3
  return ComplexPairTy(Op.first, ResI);
586
3
}
587
588
251
ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
589
251
  llvm::Value *ResR, *ResI;
590
591
251
  if (Op.LHS.first->getType()->isFloatingPointTy()) {
592
173
    ResR = Builder.CreateFAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
593
173
    if (Op.LHS.second && 
Op.RHS.second108
)
594
77
      ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
595
96
    else
596
96
      ResI = Op.LHS.second ? 
Op.LHS.second31
:
Op.RHS.second65
;
597
173
    assert(ResI && "Only one operand may be real!");
598
78
  } else {
599
78
    ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
600
78
    assert(Op.LHS.second && Op.RHS.second &&
601
78
           "Both operands of integer complex operators must be complex!");
602
78
    ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
603
78
  }
604
251
  return ComplexPairTy(ResR, ResI);
605
251
}
606
607
138
ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
608
138
  llvm::Value *ResR, *ResI;
609
138
  if (Op.LHS.first->getType()->isFloatingPointTy()) {
610
109
    ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r");
611
109
    if (Op.LHS.second && 
Op.RHS.second63
)
612
36
      ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
613
73
    else
614
73
      ResI = Op.LHS.second ? 
Op.LHS.second27
615
46
                           : Builder.CreateFNeg(Op.RHS.second, "sub.i");
616
109
    assert(ResI && "Only one operand may be real!");
617
29
  } else {
618
29
    ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r");
619
29
    assert(Op.LHS.second && Op.RHS.second &&
620
29
           "Both operands of integer complex operators must be complex!");
621
29
    ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
622
29
  }
623
138
  return ComplexPairTy(ResR, ResI);
624
138
}
625
626
/// Emit a libcall for a binary operation on complex types.
627
ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName,
628
194
                                                          const BinOpInfo &Op) {
629
194
  CallArgList Args;
630
194
  Args.add(RValue::get(Op.LHS.first),
631
194
           Op.Ty->castAs<ComplexType>()->getElementType());
632
194
  Args.add(RValue::get(Op.LHS.second),
633
194
           Op.Ty->castAs<ComplexType>()->getElementType());
634
194
  Args.add(RValue::get(Op.RHS.first),
635
194
           Op.Ty->castAs<ComplexType>()->getElementType());
636
194
  Args.add(RValue::get(Op.RHS.second),
637
194
           Op.Ty->castAs<ComplexType>()->getElementType());
638
639
  // We *must* use the full CG function call building logic here because the
640
  // complex type has special ABI handling. We also should not forget about
641
  // special calling convention which may be used for compiler builtins.
642
643
  // We create a function qualified type to state that this call does not have
644
  // any exceptions.
645
194
  FunctionProtoType::ExtProtoInfo EPI;
646
194
  EPI = EPI.withExceptionSpec(
647
194
      FunctionProtoType::ExceptionSpecInfo(EST_BasicNoexcept));
648
194
  SmallVector<QualType, 4> ArgsQTys(
649
194
      4, Op.Ty->castAs<ComplexType>()->getElementType());
650
194
  QualType FQTy = CGF.getContext().getFunctionType(Op.Ty, ArgsQTys, EPI);
651
194
  const CGFunctionInfo &FuncInfo = CGF.CGM.getTypes().arrangeFreeFunctionCall(
652
194
      Args, cast<FunctionType>(FQTy.getTypePtr()), false);
653
654
194
  llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo);
655
194
  llvm::FunctionCallee Func = CGF.CGM.CreateRuntimeFunction(
656
194
      FTy, LibCallName, llvm::AttributeList(), true);
657
194
  CGCallee Callee = CGCallee::forDirect(Func, FQTy->getAs<FunctionProtoType>());
658
659
194
  llvm::CallBase *Call;
660
194
  RValue Res = CGF.EmitCall(FuncInfo, Callee, ReturnValueSlot(), Args, &Call);
661
194
  Call->setCallingConv(CGF.CGM.getRuntimeCC());
662
194
  return Res.getComplexVal();
663
194
}
664
665
/// Lookup the libcall name for a given floating point type complex
666
/// multiply.
667
127
static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) {
668
127
  switch (Ty->getTypeID()) {
669
0
  default:
670
0
    llvm_unreachable("Unsupported floating point type!");
671
0
  case llvm::Type::HalfTyID:
672
0
    return "__mulhc3";
673
41
  case llvm::Type::FloatTyID:
674
41
    return "__mulsc3";
675
74
  case llvm::Type::DoubleTyID:
676
74
    return "__muldc3";
677
1
  case llvm::Type::PPC_FP128TyID:
678
1
    return "__multc3";
679
8
  case llvm::Type::X86_FP80TyID:
680
8
    return "__mulxc3";
681
3
  case llvm::Type::FP128TyID:
682
3
    return "__multc3";
683
127
  }
684
127
}
685
686
// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
687
// typed values.
688
190
ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
689
190
  using llvm::Value;
690
190
  Value *ResR, *ResI;
691
190
  llvm::MDBuilder MDHelper(CGF.getLLVMContext());
692
693
190
  if (Op.LHS.first->getType()->isFloatingPointTy()) {
694
    // The general formulation is:
695
    // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c)
696
    //
697
    // But we can fold away components which would be zero due to a real
698
    // operand according to C11 Annex G.5.1p2.
699
    // FIXME: C11 also provides for imaginary types which would allow folding
700
    // still more of this within the type system.
701
702
189
    if (Op.LHS.second && 
Op.RHS.second154
) {
703
      // If both operands are complex, emit the core math directly, and then
704
      // test for NaNs. If we find NaNs in the result, we delegate to a libcall
705
      // to carefully re-compute the correct infinity representation if
706
      // possible. The expectation is that the presence of NaNs here is
707
      // *extremely* rare, and so the cost of the libcall is almost irrelevant.
708
      // This is good, because the libcall re-computes the core multiplication
709
      // exactly the same as we do here and re-tests for NaNs in order to be
710
      // a generic complex*complex libcall.
711
712
      // First compute the four products.
713
127
      Value *AC = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul_ac");
714
127
      Value *BD = Builder.CreateFMul(Op.LHS.second, Op.RHS.second, "mul_bd");
715
127
      Value *AD = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul_ad");
716
127
      Value *BC = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul_bc");
717
718
      // The real part is the difference of the first two, the imaginary part is
719
      // the sum of the second.
720
127
      ResR = Builder.CreateFSub(AC, BD, "mul_r");
721
127
      ResI = Builder.CreateFAdd(AD, BC, "mul_i");
722
723
      // Emit the test for the real part becoming NaN and create a branch to
724
      // handle it. We test for NaN by comparing the number to itself.
725
127
      Value *IsRNaN = Builder.CreateFCmpUNO(ResR, ResR, "isnan_cmp");
726
127
      llvm::BasicBlock *ContBB = CGF.createBasicBlock("complex_mul_cont");
727
127
      llvm::BasicBlock *INaNBB = CGF.createBasicBlock("complex_mul_imag_nan");
728
127
      llvm::Instruction *Branch = Builder.CreateCondBr(IsRNaN, INaNBB, ContBB);
729
127
      llvm::BasicBlock *OrigBB = Branch->getParent();
730
731
      // Give hint that we very much don't expect to see NaNs.
732
      // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp
733
127
      llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1);
734
127
      Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
735
736
      // Now test the imaginary part and create its branch.
737
127
      CGF.EmitBlock(INaNBB);
738
127
      Value *IsINaN = Builder.CreateFCmpUNO(ResI, ResI, "isnan_cmp");
739
127
      llvm::BasicBlock *LibCallBB = CGF.createBasicBlock("complex_mul_libcall");
740
127
      Branch = Builder.CreateCondBr(IsINaN, LibCallBB, ContBB);
741
127
      Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
742
743
      // Now emit the libcall on this slowest of the slow paths.
744
127
      CGF.EmitBlock(LibCallBB);
745
127
      Value *LibCallR, *LibCallI;
746
127
      std::tie(LibCallR, LibCallI) = EmitComplexBinOpLibCall(
747
127
          getComplexMultiplyLibCallName(Op.LHS.first->getType()), Op);
748
127
      Builder.CreateBr(ContBB);
749
750
      // Finally continue execution by phi-ing together the different
751
      // computation paths.
752
127
      CGF.EmitBlock(ContBB);
753
127
      llvm::PHINode *RealPHI = Builder.CreatePHI(ResR->getType(), 3, "real_mul_phi");
754
127
      RealPHI->addIncoming(ResR, OrigBB);
755
127
      RealPHI->addIncoming(ResR, INaNBB);
756
127
      RealPHI->addIncoming(LibCallR, LibCallBB);
757
127
      llvm::PHINode *ImagPHI = Builder.CreatePHI(ResI->getType(), 3, "imag_mul_phi");
758
127
      ImagPHI->addIncoming(ResI, OrigBB);
759
127
      ImagPHI->addIncoming(ResI, INaNBB);
760
127
      ImagPHI->addIncoming(LibCallI, LibCallBB);
761
127
      return ComplexPairTy(RealPHI, ImagPHI);
762
127
    }
763
62
    assert((Op.LHS.second || Op.RHS.second) &&
764
62
           "At least one operand must be complex!");
765
766
    // If either of the operands is a real rather than a complex, the
767
    // imaginary component is ignored when computing the real component of the
768
    // result.
769
62
    ResR = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
770
771
62
    ResI = Op.LHS.second
772
27
               ? Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il")
773
35
               : Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
774
1
  } else {
775
1
    assert(Op.LHS.second && Op.RHS.second &&
776
1
           "Both operands of integer complex operators must be complex!");
777
1
    Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
778
1
    Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second, "mul.rr");
779
1
    ResR = Builder.CreateSub(ResRl, ResRr, "mul.r");
780
781
1
    Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
782
1
    Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
783
1
    ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i");
784
1
  }
785
63
  return ComplexPairTy(ResR, ResI);
786
190
}
787
788
// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
789
// typed values.
790
111
ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
791
111
  llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
792
111
  llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
793
794
111
  llvm::Value *DSTr, *DSTi;
795
111
  if (LHSr->getType()->isFloatingPointTy()) {
796
    // If we have a complex operand on the RHS and FastMath is not allowed, we
797
    // delegate to a libcall to handle all of the complexities and minimize
798
    // underflow/overflow cases. When FastMath is allowed we construct the
799
    // divide inline using the same algorithm as for integer operands.
800
    //
801
    // FIXME: We would be able to avoid the libcall in many places if we
802
    // supported imaginary types in addition to complex types.
803
102
    if (RHSi && 
!CGF.getLangOpts().FastMath73
) {
804
67
      BinOpInfo LibCallOp = Op;
805
      // If LHS was a real, supply a null imaginary part.
806
67
      if (!LHSi)
807
24
        LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType());
808
809
67
      switch (LHSr->getType()->getTypeID()) {
810
0
      default:
811
0
        llvm_unreachable("Unsupported floating point type!");
812
0
      case llvm::Type::HalfTyID:
813
0
        return EmitComplexBinOpLibCall("__divhc3", LibCallOp);
814
28
      case llvm::Type::FloatTyID:
815
28
        return EmitComplexBinOpLibCall("__divsc3", LibCallOp);
816
30
      case llvm::Type::DoubleTyID:
817
30
        return EmitComplexBinOpLibCall("__divdc3", LibCallOp);
818
2
      case llvm::Type::PPC_FP128TyID:
819
2
        return EmitComplexBinOpLibCall("__divtc3", LibCallOp);
820
6
      case llvm::Type::X86_FP80TyID:
821
6
        return EmitComplexBinOpLibCall("__divxc3", LibCallOp);
822
1
      case llvm::Type::FP128TyID:
823
1
        return EmitComplexBinOpLibCall("__divtc3", LibCallOp);
824
35
      }
825
35
    } else if (RHSi) {
826
6
      if (!LHSi)
827
3
        LHSi = llvm::Constant::getNullValue(RHSi->getType());
828
829
      // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
830
6
      llvm::Value *AC = Builder.CreateFMul(LHSr, RHSr); // a*c
831
6
      llvm::Value *BD = Builder.CreateFMul(LHSi, RHSi); // b*d
832
6
      llvm::Value *ACpBD = Builder.CreateFAdd(AC, BD); // ac+bd
833
834
6
      llvm::Value *CC = Builder.CreateFMul(RHSr, RHSr); // c*c
835
6
      llvm::Value *DD = Builder.CreateFMul(RHSi, RHSi); // d*d
836
6
      llvm::Value *CCpDD = Builder.CreateFAdd(CC, DD); // cc+dd
837
838
6
      llvm::Value *BC = Builder.CreateFMul(LHSi, RHSr); // b*c
839
6
      llvm::Value *AD = Builder.CreateFMul(LHSr, RHSi); // a*d
840
6
      llvm::Value *BCmAD = Builder.CreateFSub(BC, AD); // bc-ad
841
842
6
      DSTr = Builder.CreateFDiv(ACpBD, CCpDD);
843
6
      DSTi = Builder.CreateFDiv(BCmAD, CCpDD);
844
29
    } else {
845
29
      assert(LHSi && "Can have at most one non-complex operand!");
846
847
29
      DSTr = Builder.CreateFDiv(LHSr, RHSr);
848
29
      DSTi = Builder.CreateFDiv(LHSi, RHSr);
849
29
    }
850
9
  } else {
851
9
    assert(Op.LHS.second && Op.RHS.second &&
852
9
           "Both operands of integer complex operators must be complex!");
853
    // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
854
9
    llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
855
9
    llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
856
9
    llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
857
858
9
    llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
859
9
    llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
860
9
    llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
861
862
9
    llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
863
9
    llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
864
9
    llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
865
866
9
    if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
867
0
      DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
868
0
      DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
869
9
    } else {
870
9
      DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
871
9
      DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
872
9
    }
873
9
  }
874
875
44
  return ComplexPairTy(DSTr, DSTi);
876
111
}
877
878
ComplexExprEmitter::BinOpInfo
879
607
ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
880
607
  TestAndClearIgnoreReal();
881
607
  TestAndClearIgnoreImag();
882
607
  BinOpInfo Ops;
883
607
  if (E->getLHS()->getType()->isRealFloatingType())
884
170
    Ops.LHS = ComplexPairTy(CGF.EmitScalarExpr(E->getLHS()), nullptr);
885
437
  else
886
437
    Ops.LHS = Visit(E->getLHS());
887
607
  if (E->getRHS()->getType()->isRealFloatingType())
888
111
    Ops.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr);
889
496
  else
890
496
    Ops.RHS = Visit(E->getRHS());
891
892
607
  Ops.Ty = E->getType();
893
607
  return Ops;
894
607
}
895
896
897
LValue ComplexExprEmitter::
898
EmitCompoundAssignLValue(const CompoundAssignOperator *E,
899
          ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
900
83
                         RValue &Val) {
901
83
  TestAndClearIgnoreReal();
902
83
  TestAndClearIgnoreImag();
903
83
  QualType LHSTy = E->getLHS()->getType();
904
83
  if (const AtomicType *AT = LHSTy->getAs<AtomicType>())
905
2
    LHSTy = AT->getValueType();
906
907
83
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
908
83
  BinOpInfo OpInfo;
909
910
  // Load the RHS and LHS operands.
911
  // __block variables need to have the rhs evaluated first, plus this should
912
  // improve codegen a little.
913
83
  OpInfo.Ty = E->getComputationResultType();
914
83
  QualType ComplexElementTy = cast<ComplexType>(OpInfo.Ty)->getElementType();
915
916
  // The RHS should have been converted to the computation type.
917
83
  if (E->getRHS()->getType()->isRealFloatingType()) {
918
3
    assert(
919
3
        CGF.getContext()
920
3
            .hasSameUnqualifiedType(ComplexElementTy, E->getRHS()->getType()));
921
3
    OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr);
922
80
  } else {
923
80
    assert(CGF.getContext()
924
80
               .hasSameUnqualifiedType(OpInfo.Ty, E->getRHS()->getType()));
925
80
    OpInfo.RHS = Visit(E->getRHS());
926
80
  }
927
928
83
  LValue LHS = CGF.EmitLValue(E->getLHS());
929
930
  // Load from the l-value and convert it.
931
83
  SourceLocation Loc = E->getExprLoc();
932
83
  if (LHSTy->isAnyComplexType()) {
933
79
    ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, Loc);
934
79
    OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc);
935
4
  } else {
936
4
    llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, Loc);
937
    // For floating point real operands we can directly pass the scalar form
938
    // to the binary operator emission and potentially get more efficient code.
939
4
    if (LHSTy->isRealFloatingType()) {
940
3
      if (!CGF.getContext().hasSameUnqualifiedType(ComplexElementTy, LHSTy))
941
0
        LHSVal = CGF.EmitScalarConversion(LHSVal, LHSTy, ComplexElementTy, Loc);
942
3
      OpInfo.LHS = ComplexPairTy(LHSVal, nullptr);
943
1
    } else {
944
1
      OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc);
945
1
    }
946
4
  }
947
948
  // Expand the binary operator.
949
83
  ComplexPairTy Result = (this->*Func)(OpInfo);
950
951
  // Truncate the result and store it into the LHS lvalue.
952
83
  if (LHSTy->isAnyComplexType()) {
953
79
    ComplexPairTy ResVal =
954
79
        EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy, Loc);
955
79
    EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false);
956
79
    Val = RValue::getComplex(ResVal);
957
4
  } else {
958
4
    llvm::Value *ResVal =
959
4
        CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy, Loc);
960
4
    CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false);
961
4
    Val = RValue::get(ResVal);
962
4
  }
963
964
83
  return LHS;
965
83
}
966
967
// Compound assignments.
968
ComplexPairTy ComplexExprEmitter::
969
EmitCompoundAssign(const CompoundAssignOperator *E,
970
15
                   ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
971
15
  RValue Val;
972
15
  LValue LV = EmitCompoundAssignLValue(E, Func, Val);
973
974
  // The result of an assignment in C is the assigned r-value.
975
15
  if (!CGF.getLangOpts().CPlusPlus)
976
13
    return Val.getComplexVal();
977
978
  // If the lvalue is non-volatile, return the computed value of the assignment.
979
2
  if (!LV.isVolatileQualified())
980
0
    return Val.getComplexVal();
981
982
2
  return EmitLoadOfLValue(LV, E->getExprLoc());
983
2
}
984
985
LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
986
183
                                               ComplexPairTy &Val) {
987
183
  assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
988
183
                                                 E->getRHS()->getType()) &&
989
183
         "Invalid assignment");
990
183
  TestAndClearIgnoreReal();
991
183
  TestAndClearIgnoreImag();
992
993
  // Emit the RHS.  __block variables need the RHS evaluated first.
994
183
  Val = Visit(E->getRHS());
995
996
  // Compute the address to store into.
997
183
  LValue LHS = CGF.EmitLValue(E->getLHS());
998
999
  // Store the result value into the LHS lvalue.
1000
183
  EmitStoreOfComplex(Val, LHS, /*isInit*/ false);
1001
1002
183
  return LHS;
1003
183
}
1004
1005
152
ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
1006
152
  ComplexPairTy Val;
1007
152
  LValue LV = EmitBinAssignLValue(E, Val);
1008
1009
  // The result of an assignment in C is the assigned r-value.
1010
152
  if (!CGF.getLangOpts().CPlusPlus)
1011
146
    return Val;
1012
1013
  // If the lvalue is non-volatile, return the computed value of the assignment.
1014
6
  if (!LV.isVolatileQualified())
1015
0
    return Val;
1016
1017
6
  return EmitLoadOfLValue(LV, E->getExprLoc());
1018
6
}
1019
1020
0
ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
1021
0
  CGF.EmitIgnoredExpr(E->getLHS());
1022
0
  return Visit(E->getRHS());
1023
0
}
1024
1025
ComplexPairTy ComplexExprEmitter::
1026
11
VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
1027
11
  TestAndClearIgnoreReal();
1028
11
  TestAndClearIgnoreImag();
1029
11
  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
1030
11
  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
1031
11
  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
1032
1033
  // Bind the common expression if necessary.
1034
11
  CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1035
1036
1037
11
  CodeGenFunction::ConditionalEvaluation eval(CGF);
1038
11
  CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
1039
11
                           CGF.getProfileCount(E));
1040
1041
11
  eval.begin(CGF);
1042
11
  CGF.EmitBlock(LHSBlock);
1043
11
  CGF.incrementProfileCounter(E);
1044
11
  ComplexPairTy LHS = Visit(E->getTrueExpr());
1045
11
  LHSBlock = Builder.GetInsertBlock();
1046
11
  CGF.EmitBranch(ContBlock);
1047
11
  eval.end(CGF);
1048
1049
11
  eval.begin(CGF);
1050
11
  CGF.EmitBlock(RHSBlock);
1051
11
  ComplexPairTy RHS = Visit(E->getFalseExpr());
1052
11
  RHSBlock = Builder.GetInsertBlock();
1053
11
  CGF.EmitBlock(ContBlock);
1054
11
  eval.end(CGF);
1055
1056
  // Create a PHI node for the real part.
1057
11
  llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
1058
11
  RealPN->addIncoming(LHS.first, LHSBlock);
1059
11
  RealPN->addIncoming(RHS.first, RHSBlock);
1060
1061
  // Create a PHI node for the imaginary part.
1062
11
  llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
1063
11
  ImagPN->addIncoming(LHS.second, LHSBlock);
1064
11
  ImagPN->addIncoming(RHS.second, RHSBlock);
1065
1066
11
  return ComplexPairTy(RealPN, ImagPN);
1067
11
}
1068
1069
0
ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
1070
0
  return Visit(E->getChosenSubExpr());
1071
0
}
1072
1073
38
ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
1074
38
    bool Ignore = TestAndClearIgnoreReal();
1075
38
    (void)Ignore;
1076
38
    assert (Ignore == false && "init list ignored");
1077
38
    Ignore = TestAndClearIgnoreImag();
1078
38
    (void)Ignore;
1079
38
    assert (Ignore == false && "init list ignored");
1080
1081
38
  if (E->getNumInits() == 2) {
1082
20
    llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
1083
20
    llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
1084
20
    return ComplexPairTy(Real, Imag);
1085
18
  } else if (E->getNumInits() == 1) {
1086
2
    return Visit(E->getInit(0));
1087
2
  }
1088
1089
  // Empty init list initializes to null
1090
16
  assert(E->getNumInits() == 0 && "Unexpected number of inits");
1091
16
  QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
1092
16
  llvm::Type* LTy = CGF.ConvertType(Ty);
1093
16
  llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
1094
16
  return ComplexPairTy(zeroConstant, zeroConstant);
1095
16
}
1096
1097
27
ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
1098
27
  Address ArgValue = Address::invalid();
1099
27
  Address ArgPtr = CGF.EmitVAArg(E, ArgValue);
1100
1101
27
  if (!ArgPtr.isValid()) {
1102
0
    CGF.ErrorUnsupported(E, "complex va_arg expression");
1103
0
    llvm::Type *EltTy =
1104
0
      CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType());
1105
0
    llvm::Value *U = llvm::UndefValue::get(EltTy);
1106
0
    return ComplexPairTy(U, U);
1107
0
  }
1108
1109
27
  return EmitLoadOfLValue(CGF.MakeAddrLValue(ArgPtr, E->getType()),
1110
27
                          E->getExprLoc());
1111
27
}
1112
1113
//===----------------------------------------------------------------------===//
1114
//                         Entry Point into this File
1115
//===----------------------------------------------------------------------===//
1116
1117
/// EmitComplexExpr - Emit the computation of the specified expression of
1118
/// complex type, ignoring the result.
1119
ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
1120
1.31k
                                               bool IgnoreImag) {
1121
1.31k
  assert(E && getComplexType(E->getType()) &&
1122
1.31k
         "Invalid complex expression to emit");
1123
1124
1.31k
  return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
1125
1.31k
      .Visit(const_cast<Expr *>(E));
1126
1.31k
}
1127
1128
void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
1129
687
                                                bool isInit) {
1130
687
  assert(E && getComplexType(E->getType()) &&
1131
687
         "Invalid complex expression to emit");
1132
687
  ComplexExprEmitter Emitter(*this);
1133
687
  ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
1134
687
  Emitter.EmitStoreOfComplex(Val, dest, isInit);
1135
687
}
1136
1137
/// EmitStoreOfComplex - Store a complex number into the specified l-value.
1138
void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
1139
899
                                         bool isInit) {
1140
899
  ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
1141
899
}
1142
1143
/// EmitLoadOfComplex - Load a complex number from the specified address.
1144
ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src,
1145
537
                                                 SourceLocation loc) {
1146
537
  return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc);
1147
537
}
1148
1149
31
LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
1150
31
  assert(E->getOpcode() == BO_Assign);
1151
31
  ComplexPairTy Val; // ignored
1152
31
  LValue LVal = ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
1153
31
  if (getLangOpts().OpenMP)
1154
4
    CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(*this,
1155
4
                                                              E->getLHS());
1156
31
  return LVal;
1157
31
}
1158
1159
typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)(
1160
    const ComplexExprEmitter::BinOpInfo &);
1161
1162
68
static CompoundFunc getComplexOp(BinaryOperatorKind Op) {
1163
68
  switch (Op) {
1164
58
  case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul;
1165
0
  case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv;
1166
0
  case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub;
1167
10
  case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd;
1168
0
  default:
1169
0
    llvm_unreachable("unexpected complex compound assignment");
1170
68
  }
1171
68
}
1172
1173
LValue CodeGenFunction::
1174
64
EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
1175
64
  CompoundFunc Op = getComplexOp(E->getOpcode());
1176
64
  RValue Val;
1177
64
  return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
1178
64
}
1179
1180
LValue CodeGenFunction::
1181
EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
1182
4
                                    llvm::Value *&Result) {
1183
4
  CompoundFunc Op = getComplexOp(E->getOpcode());
1184
4
  RValue Val;
1185
4
  LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
1186
4
  Result = Val.getScalarVal();
1187
4
  return Ret;
1188
4
}