Coverage Report

Created: 2021-08-24 07:12

/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.11k
static const ComplexType *getComplexType(QualType type) {
35
2.11k
  type = type.getCanonicalType();
36
2.11k
  if (const ComplexType *comp = dyn_cast<ComplexType>(type)) {
37
2.10k
    return comp;
38
2.10k
  } else {
39
6
    return cast<ComplexType>(cast<AtomicType>(type)->getValueType());
40
6
  }
41
2.11k
}
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.72k
    : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
53
3.72k
  }
54
55
56
  //===--------------------------------------------------------------------===//
57
  //                               Utilities
58
  //===--------------------------------------------------------------------===//
59
60
999
  bool TestAndClearIgnoreReal() {
61
999
    bool I = IgnoreReal;
62
999
    IgnoreReal = false;
63
999
    return I;
64
999
  }
65
999
  bool TestAndClearIgnoreImag() {
66
999
    bool I = IgnoreImag;
67
999
    IgnoreImag = false;
68
999
    return I;
69
999
  }
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.25k
  ComplexPairTy EmitLoadOfLValue(const Expr *E) {
75
1.25k
    return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc());
76
1.25k
  }
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
5.03k
  ComplexPairTy Visit(Expr *E) {
96
5.03k
    ApplyDebugLocation DL(CGF, E);
97
5.03k
    return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
98
5.03k
  }
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
102
  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
0
  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
118
0
    return Visit(PE->getReplacement());
119
0
  }
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
9
  }
141
142
  // l-values.
143
1.23k
  ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) {
144
1.23k
    if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
145
4
      return emitConstant(Constant, E);
146
1.22k
    return EmitLoadOfLValue(E);
147
1.23k
  }
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
9
            CGF.tryEmitAsConstant(ME)) {
158
5
      CGF.EmitIgnoredExpr(ME->getBase());
159
5
      return emitConstant(Constant, ME);
160
5
    }
161
4
    return EmitLoadOfLValue(ME);
162
9
  }
163
91
  ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
164
91
    if (E->isGLValue())
165
3
      return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
166
3
                              E->getExprLoc());
167
88
    return CGF.getOrCreateOpaqueRValueMapping(E).getComplexVal();
168
91
  }
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
2.10k
  ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
178
    // Unlike for scalars, we don't have to worry about function->ptr demotion
179
    // here.
180
2.10k
    return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
181
2.10k
  }
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
0
    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
0
    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
244
  ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
274
244
    return EmitBinAdd(EmitBinOps(E));
275
244
  }
276
149
  ComplexPairTy VisitBinSub(const BinaryOperator *E) {
277
149
    return EmitBinSub(EmitBinOps(E));
278
149
  }
279
138
  ComplexPairTy VisitBinMul(const BinaryOperator *E) {
280
138
    return EmitBinMul(EmitBinOps(E));
281
138
  }
282
121
  ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
283
121
    return EmitBinDiv(EmitBinOps(E));
284
121
  }
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
4.04k
                                                 QualType complexType) {
339
4.04k
  return Builder.CreateStructGEP(addr, 0, addr.getName() + ".realp");
340
4.04k
}
341
342
Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
343
4.01k
                                                 QualType complexType) {
344
4.01k
  return Builder.CreateStructGEP(addr, 1, addr.getName() + ".imagp");
345
4.01k
}
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.96k
                                                   SourceLocation loc) {
351
1.96k
  assert(lvalue.isSimple() && "non-simple complex l-value?");
352
1.96k
  if (lvalue.getType()->isAtomicType())
353
4
    return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal();
354
355
1.96k
  Address SrcPtr = lvalue.getAddress(CGF);
356
1.96k
  bool isVolatile = lvalue.isVolatileQualified();
357
358
1.96k
  llvm::Value *Real = nullptr, *Imag = nullptr;
359
360
1.96k
  if (!IgnoreReal || 
isVolatile9
) {
361
1.96k
    Address RealP = CGF.emitAddrOfRealComponent(SrcPtr, lvalue.getType());
362
1.96k
    Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr.getName() + ".real");
363
1.96k
  }
364
365
1.96k
  if (!IgnoreImag || 
isVolatile45
) {
366
1.93k
    Address ImagP = CGF.emitAddrOfImagComponent(SrcPtr, lvalue.getType());
367
1.93k
    Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr.getName() + ".imag");
368
1.93k
  }
369
370
1.96k
  return ComplexPairTy(Real, Imag);
371
1.96k
}
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.96k
                                            bool isInit) {
377
1.96k
  if (lvalue.getType()->isAtomicType() ||
378
1.96k
      
(1.96k
!isInit1.96k
&&
CGF.LValueIsSuitableForInlineAtomic(lvalue)367
))
379
6
    return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit);
380
381
1.96k
  Address Ptr = lvalue.getAddress(CGF);
382
1.96k
  Address RealPtr = CGF.emitAddrOfRealComponent(Ptr, lvalue.getType());
383
1.96k
  Address ImagPtr = CGF.emitAddrOfImagComponent(Ptr, lvalue.getType());
384
385
1.96k
  Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified());
386
1.96k
  Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified());
387
1.96k
}
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
328
ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
411
328
  if (E->getCallReturnType(CGF.getContext())->isReferenceType())
412
2
    return EmitLoadOfLValue(E);
413
414
326
  return CGF.EmitCallExpr(E).getComplexVal();
415
328
}
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
326
                                                           SourceLocation Loc) {
430
  // Get the src/dest element type.
431
326
  SrcType = SrcType->castAs<ComplexType>()->getElementType();
432
326
  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
326
  if (Val.first)
438
325
    Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType, Loc);
439
326
  if (Val.second)
440
325
    Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType, Loc);
441
326
  return Val;
442
326
}
443
444
ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val,
445
                                                          QualType SrcType,
446
                                                          QualType DestType,
447
656
                                                          SourceLocation Loc) {
448
  // Convert the input element to the element type of the complex.
449
656
  DestType = DestType->castAs<ComplexType>()->getElementType();
450
656
  Val = CGF.EmitScalarConversion(Val, SrcType, DestType, Loc);
451
452
  // Return (realval, 0).
453
656
  return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType()));
454
656
}
455
456
ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
457
2.12k
                                           QualType DestTy) {
458
2.12k
  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.28k
  case CK_LValueToRValue:
467
1.28k
  case CK_UserDefinedConversion:
468
1.28k
    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.28k
  }
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.28k
  }
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
  case CK_MatrixCast:
537
0
    llvm_unreachable("invalid cast kind for complex value");
538
539
530
  case CK_FloatingRealToComplex:
540
655
  case CK_IntegralRealToComplex: {
541
655
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
542
655
    return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(),
543
655
                                   DestTy, Op->getExprLoc());
544
530
  }
545
546
51
  case CK_FloatingComplexCast:
547
79
  case CK_FloatingComplexToIntegralComplex:
548
151
  case CK_IntegralComplexCast:
549
168
  case CK_IntegralComplexToFloatingComplex: {
550
168
    CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
551
168
    return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy,
552
168
                                    Op->getExprLoc());
553
151
  }
554
2.12k
  }
555
556
0
  llvm_unreachable("unknown cast resulting in complex value");
557
0
}
558
559
3
ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
560
3
  TestAndClearIgnoreReal();
561
3
  TestAndClearIgnoreImag();
562
3
  ComplexPairTy Op = Visit(E->getSubExpr());
563
564
3
  llvm::Value *ResR, *ResI;
565
3
  if (Op.first->getType()->isFloatingPointTy()) {
566
2
    ResR = Builder.CreateFNeg(Op.first,  "neg.r");
567
2
    ResI = Builder.CreateFNeg(Op.second, "neg.i");
568
2
  } else {
569
1
    ResR = Builder.CreateNeg(Op.first,  "neg.r");
570
1
    ResI = Builder.CreateNeg(Op.second, "neg.i");
571
1
  }
572
3
  return ComplexPairTy(ResR, ResI);
573
3
}
574
575
3
ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
576
3
  TestAndClearIgnoreReal();
577
3
  TestAndClearIgnoreImag();
578
  // ~(a+ib) = a + i*-b
579
3
  ComplexPairTy Op = Visit(E->getSubExpr());
580
3
  llvm::Value *ResI;
581
3
  if (Op.second->getType()->isFloatingPointTy())
582
2
    ResI = Builder.CreateFNeg(Op.second, "conj.i");
583
1
  else
584
1
    ResI = Builder.CreateNeg(Op.second, "conj.i");
585
586
3
  return ComplexPairTy(Op.first, ResI);
587
3
}
588
589
263
ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
590
263
  llvm::Value *ResR, *ResI;
591
592
263
  if (Op.LHS.first->getType()->isFloatingPointTy()) {
593
181
    ResR = Builder.CreateFAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
594
181
    if (Op.LHS.second && 
Op.RHS.second115
)
595
83
      ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
596
98
    else
597
98
      ResI = Op.LHS.second ? 
Op.LHS.second32
:
Op.RHS.second66
;
598
181
    assert(ResI && "Only one operand may be real!");
599
181
  } else {
600
82
    ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
601
82
    assert(Op.LHS.second && Op.RHS.second &&
602
82
           "Both operands of integer complex operators must be complex!");
603
0
    ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
604
82
  }
605
0
  return ComplexPairTy(ResR, ResI);
606
263
}
607
608
149
ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
609
149
  llvm::Value *ResR, *ResI;
610
149
  if (Op.LHS.first->getType()->isFloatingPointTy()) {
611
116
    ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r");
612
116
    if (Op.LHS.second && 
Op.RHS.second69
)
613
41
      ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
614
75
    else
615
75
      ResI = Op.LHS.second ? 
Op.LHS.second28
616
75
                           : 
Builder.CreateFNeg(Op.RHS.second, "sub.i")47
;
617
116
    assert(ResI && "Only one operand may be real!");
618
116
  } else {
619
33
    ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r");
620
33
    assert(Op.LHS.second && Op.RHS.second &&
621
33
           "Both operands of integer complex operators must be complex!");
622
0
    ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
623
33
  }
624
0
  return ComplexPairTy(ResR, ResI);
625
149
}
626
627
/// Emit a libcall for a binary operation on complex types.
628
ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName,
629
209
                                                          const BinOpInfo &Op) {
630
209
  CallArgList Args;
631
209
  Args.add(RValue::get(Op.LHS.first),
632
209
           Op.Ty->castAs<ComplexType>()->getElementType());
633
209
  Args.add(RValue::get(Op.LHS.second),
634
209
           Op.Ty->castAs<ComplexType>()->getElementType());
635
209
  Args.add(RValue::get(Op.RHS.first),
636
209
           Op.Ty->castAs<ComplexType>()->getElementType());
637
209
  Args.add(RValue::get(Op.RHS.second),
638
209
           Op.Ty->castAs<ComplexType>()->getElementType());
639
640
  // We *must* use the full CG function call building logic here because the
641
  // complex type has special ABI handling. We also should not forget about
642
  // special calling convention which may be used for compiler builtins.
643
644
  // We create a function qualified type to state that this call does not have
645
  // any exceptions.
646
209
  FunctionProtoType::ExtProtoInfo EPI;
647
209
  EPI = EPI.withExceptionSpec(
648
209
      FunctionProtoType::ExceptionSpecInfo(EST_BasicNoexcept));
649
209
  SmallVector<QualType, 4> ArgsQTys(
650
209
      4, Op.Ty->castAs<ComplexType>()->getElementType());
651
209
  QualType FQTy = CGF.getContext().getFunctionType(Op.Ty, ArgsQTys, EPI);
652
209
  const CGFunctionInfo &FuncInfo = CGF.CGM.getTypes().arrangeFreeFunctionCall(
653
209
      Args, cast<FunctionType>(FQTy.getTypePtr()), false);
654
655
209
  llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo);
656
209
  llvm::FunctionCallee Func = CGF.CGM.CreateRuntimeFunction(
657
209
      FTy, LibCallName, llvm::AttributeList(), true);
658
209
  CGCallee Callee = CGCallee::forDirect(Func, FQTy->getAs<FunctionProtoType>());
659
660
209
  llvm::CallBase *Call;
661
209
  RValue Res = CGF.EmitCall(FuncInfo, Callee, ReturnValueSlot(), Args, &Call);
662
209
  Call->setCallingConv(CGF.CGM.getRuntimeCC());
663
209
  return Res.getComplexVal();
664
209
}
665
666
/// Lookup the libcall name for a given floating point type complex
667
/// multiply.
668
132
static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) {
669
132
  switch (Ty->getTypeID()) {
670
0
  default:
671
0
    llvm_unreachable("Unsupported floating point type!");
672
1
  case llvm::Type::HalfTyID:
673
1
    return "__mulhc3";
674
43
  case llvm::Type::FloatTyID:
675
43
    return "__mulsc3";
676
76
  case llvm::Type::DoubleTyID:
677
76
    return "__muldc3";
678
1
  case llvm::Type::PPC_FP128TyID:
679
1
    return "__multc3";
680
8
  case llvm::Type::X86_FP80TyID:
681
8
    return "__mulxc3";
682
3
  case llvm::Type::FP128TyID:
683
3
    return "__multc3";
684
132
  }
685
132
}
686
687
// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
688
// typed values.
689
197
ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
690
197
  using llvm::Value;
691
197
  Value *ResR, *ResI;
692
197
  llvm::MDBuilder MDHelper(CGF.getLLVMContext());
693
694
197
  if (Op.LHS.first->getType()->isFloatingPointTy()) {
695
    // The general formulation is:
696
    // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c)
697
    //
698
    // But we can fold away components which would be zero due to a real
699
    // operand according to C11 Annex G.5.1p2.
700
    // FIXME: C11 also provides for imaginary types which would allow folding
701
    // still more of this within the type system.
702
703
196
    if (Op.LHS.second && 
Op.RHS.second160
) {
704
      // If both operands are complex, emit the core math directly, and then
705
      // test for NaNs. If we find NaNs in the result, we delegate to a libcall
706
      // to carefully re-compute the correct infinity representation if
707
      // possible. The expectation is that the presence of NaNs here is
708
      // *extremely* rare, and so the cost of the libcall is almost irrelevant.
709
      // This is good, because the libcall re-computes the core multiplication
710
      // exactly the same as we do here and re-tests for NaNs in order to be
711
      // a generic complex*complex libcall.
712
713
      // First compute the four products.
714
132
      Value *AC = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul_ac");
715
132
      Value *BD = Builder.CreateFMul(Op.LHS.second, Op.RHS.second, "mul_bd");
716
132
      Value *AD = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul_ad");
717
132
      Value *BC = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul_bc");
718
719
      // The real part is the difference of the first two, the imaginary part is
720
      // the sum of the second.
721
132
      ResR = Builder.CreateFSub(AC, BD, "mul_r");
722
132
      ResI = Builder.CreateFAdd(AD, BC, "mul_i");
723
724
      // Emit the test for the real part becoming NaN and create a branch to
725
      // handle it. We test for NaN by comparing the number to itself.
726
132
      Value *IsRNaN = Builder.CreateFCmpUNO(ResR, ResR, "isnan_cmp");
727
132
      llvm::BasicBlock *ContBB = CGF.createBasicBlock("complex_mul_cont");
728
132
      llvm::BasicBlock *INaNBB = CGF.createBasicBlock("complex_mul_imag_nan");
729
132
      llvm::Instruction *Branch = Builder.CreateCondBr(IsRNaN, INaNBB, ContBB);
730
132
      llvm::BasicBlock *OrigBB = Branch->getParent();
731
732
      // Give hint that we very much don't expect to see NaNs.
733
      // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp
734
132
      llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1);
735
132
      Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
736
737
      // Now test the imaginary part and create its branch.
738
132
      CGF.EmitBlock(INaNBB);
739
132
      Value *IsINaN = Builder.CreateFCmpUNO(ResI, ResI, "isnan_cmp");
740
132
      llvm::BasicBlock *LibCallBB = CGF.createBasicBlock("complex_mul_libcall");
741
132
      Branch = Builder.CreateCondBr(IsINaN, LibCallBB, ContBB);
742
132
      Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
743
744
      // Now emit the libcall on this slowest of the slow paths.
745
132
      CGF.EmitBlock(LibCallBB);
746
132
      Value *LibCallR, *LibCallI;
747
132
      std::tie(LibCallR, LibCallI) = EmitComplexBinOpLibCall(
748
132
          getComplexMultiplyLibCallName(Op.LHS.first->getType()), Op);
749
132
      Builder.CreateBr(ContBB);
750
751
      // Finally continue execution by phi-ing together the different
752
      // computation paths.
753
132
      CGF.EmitBlock(ContBB);
754
132
      llvm::PHINode *RealPHI = Builder.CreatePHI(ResR->getType(), 3, "real_mul_phi");
755
132
      RealPHI->addIncoming(ResR, OrigBB);
756
132
      RealPHI->addIncoming(ResR, INaNBB);
757
132
      RealPHI->addIncoming(LibCallR, LibCallBB);
758
132
      llvm::PHINode *ImagPHI = Builder.CreatePHI(ResI->getType(), 3, "imag_mul_phi");
759
132
      ImagPHI->addIncoming(ResI, OrigBB);
760
132
      ImagPHI->addIncoming(ResI, INaNBB);
761
132
      ImagPHI->addIncoming(LibCallI, LibCallBB);
762
132
      return ComplexPairTy(RealPHI, ImagPHI);
763
132
    }
764
64
    assert((Op.LHS.second || Op.RHS.second) &&
765
64
           "At least one operand must be complex!");
766
767
    // If either of the operands is a real rather than a complex, the
768
    // imaginary component is ignored when computing the real component of the
769
    // result.
770
0
    ResR = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
771
772
64
    ResI = Op.LHS.second
773
64
               ? 
Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il")28
774
64
               : 
Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir")36
;
775
64
  } else {
776
1
    assert(Op.LHS.second && Op.RHS.second &&
777
1
           "Both operands of integer complex operators must be complex!");
778
0
    Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
779
1
    Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second, "mul.rr");
780
1
    ResR = Builder.CreateSub(ResRl, ResRr, "mul.r");
781
782
1
    Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
783
1
    Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
784
1
    ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i");
785
1
  }
786
65
  return ComplexPairTy(ResR, ResI);
787
197
}
788
789
// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
790
// typed values.
791
126
ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
792
126
  llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
793
126
  llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
794
795
126
  llvm::Value *DSTr, *DSTi;
796
126
  if (LHSr->getType()->isFloatingPointTy()) {
797
    // If we have a complex operand on the RHS and FastMath is not allowed, we
798
    // delegate to a libcall to handle all of the complexities and minimize
799
    // underflow/overflow cases. When FastMath is allowed we construct the
800
    // divide inline using the same algorithm as for integer operands.
801
    //
802
    // FIXME: We would be able to avoid the libcall in many places if we
803
    // supported imaginary types in addition to complex types.
804
113
    if (RHSi && 
!CGF.getLangOpts().FastMath83
) {
805
77
      BinOpInfo LibCallOp = Op;
806
      // If LHS was a real, supply a null imaginary part.
807
77
      if (!LHSi)
808
25
        LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType());
809
810
77
      switch (LHSr->getType()->getTypeID()) {
811
0
      default:
812
0
        llvm_unreachable("Unsupported floating point type!");
813
2
      case llvm::Type::HalfTyID:
814
2
        return EmitComplexBinOpLibCall("__divhc3", LibCallOp);
815
34
      case llvm::Type::FloatTyID:
816
34
        return EmitComplexBinOpLibCall("__divsc3", LibCallOp);
817
32
      case llvm::Type::DoubleTyID:
818
32
        return EmitComplexBinOpLibCall("__divdc3", LibCallOp);
819
2
      case llvm::Type::PPC_FP128TyID:
820
2
        return EmitComplexBinOpLibCall("__divtc3", LibCallOp);
821
6
      case llvm::Type::X86_FP80TyID:
822
6
        return EmitComplexBinOpLibCall("__divxc3", LibCallOp);
823
1
      case llvm::Type::FP128TyID:
824
1
        return EmitComplexBinOpLibCall("__divtc3", LibCallOp);
825
77
      }
826
77
    } else 
if (36
RHSi36
) {
827
6
      if (!LHSi)
828
3
        LHSi = llvm::Constant::getNullValue(RHSi->getType());
829
830
      // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
831
6
      llvm::Value *AC = Builder.CreateFMul(LHSr, RHSr); // a*c
832
6
      llvm::Value *BD = Builder.CreateFMul(LHSi, RHSi); // b*d
833
6
      llvm::Value *ACpBD = Builder.CreateFAdd(AC, BD); // ac+bd
834
835
6
      llvm::Value *CC = Builder.CreateFMul(RHSr, RHSr); // c*c
836
6
      llvm::Value *DD = Builder.CreateFMul(RHSi, RHSi); // d*d
837
6
      llvm::Value *CCpDD = Builder.CreateFAdd(CC, DD); // cc+dd
838
839
6
      llvm::Value *BC = Builder.CreateFMul(LHSi, RHSr); // b*c
840
6
      llvm::Value *AD = Builder.CreateFMul(LHSr, RHSi); // a*d
841
6
      llvm::Value *BCmAD = Builder.CreateFSub(BC, AD); // bc-ad
842
843
6
      DSTr = Builder.CreateFDiv(ACpBD, CCpDD);
844
6
      DSTi = Builder.CreateFDiv(BCmAD, CCpDD);
845
30
    } else {
846
30
      assert(LHSi && "Can have at most one non-complex operand!");
847
848
0
      DSTr = Builder.CreateFDiv(LHSr, RHSr);
849
30
      DSTi = Builder.CreateFDiv(LHSi, RHSr);
850
30
    }
851
113
  } else {
852
13
    assert(Op.LHS.second && Op.RHS.second &&
853
13
           "Both operands of integer complex operators must be complex!");
854
    // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
855
0
    llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
856
13
    llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
857
13
    llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
858
859
13
    llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
860
13
    llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
861
13
    llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
862
863
13
    llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
864
13
    llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
865
13
    llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
866
867
13
    if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
868
0
      DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
869
0
      DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
870
13
    } else {
871
13
      DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
872
13
      DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
873
13
    }
874
13
  }
875
876
49
  return ComplexPairTy(DSTr, DSTi);
877
126
}
878
879
ComplexExprEmitter::BinOpInfo
880
652
ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
881
652
  TestAndClearIgnoreReal();
882
652
  TestAndClearIgnoreImag();
883
652
  BinOpInfo Ops;
884
652
  if (E->getLHS()->getType()->isRealFloatingType())
885
174
    Ops.LHS = ComplexPairTy(CGF.EmitScalarExpr(E->getLHS()), nullptr);
886
478
  else
887
478
    Ops.LHS = Visit(E->getLHS());
888
652
  if (E->getRHS()->getType()->isRealFloatingType())
889
115
    Ops.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr);
890
537
  else
891
537
    Ops.RHS = Visit(E->getRHS());
892
893
652
  Ops.Ty = E->getType();
894
652
  return Ops;
895
652
}
896
897
898
LValue ComplexExprEmitter::
899
EmitCompoundAssignLValue(const CompoundAssignOperator *E,
900
          ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
901
83
                         RValue &Val) {
902
83
  TestAndClearIgnoreReal();
903
83
  TestAndClearIgnoreImag();
904
83
  QualType LHSTy = E->getLHS()->getType();
905
83
  if (const AtomicType *AT = LHSTy->getAs<AtomicType>())
906
2
    LHSTy = AT->getValueType();
907
908
83
  CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
909
83
  BinOpInfo OpInfo;
910
911
  // Load the RHS and LHS operands.
912
  // __block variables need to have the rhs evaluated first, plus this should
913
  // improve codegen a little.
914
83
  OpInfo.Ty = E->getComputationResultType();
915
83
  QualType ComplexElementTy = cast<ComplexType>(OpInfo.Ty)->getElementType();
916
917
  // The RHS should have been converted to the computation type.
918
83
  if (E->getRHS()->getType()->isRealFloatingType()) {
919
3
    assert(
920
3
        CGF.getContext()
921
3
            .hasSameUnqualifiedType(ComplexElementTy, E->getRHS()->getType()));
922
0
    OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr);
923
80
  } else {
924
80
    assert(CGF.getContext()
925
80
               .hasSameUnqualifiedType(OpInfo.Ty, E->getRHS()->getType()));
926
0
    OpInfo.RHS = Visit(E->getRHS());
927
80
  }
928
929
0
  LValue LHS = CGF.EmitLValue(E->getLHS());
930
931
  // Load from the l-value and convert it.
932
83
  SourceLocation Loc = E->getExprLoc();
933
83
  if (LHSTy->isAnyComplexType()) {
934
79
    ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, Loc);
935
79
    OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc);
936
79
  } else {
937
4
    llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, Loc);
938
    // For floating point real operands we can directly pass the scalar form
939
    // to the binary operator emission and potentially get more efficient code.
940
4
    if (LHSTy->isRealFloatingType()) {
941
3
      if (!CGF.getContext().hasSameUnqualifiedType(ComplexElementTy, LHSTy))
942
0
        LHSVal = CGF.EmitScalarConversion(LHSVal, LHSTy, ComplexElementTy, Loc);
943
3
      OpInfo.LHS = ComplexPairTy(LHSVal, nullptr);
944
3
    } else {
945
1
      OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc);
946
1
    }
947
4
  }
948
949
  // Expand the binary operator.
950
83
  ComplexPairTy Result = (this->*Func)(OpInfo);
951
952
  // Truncate the result and store it into the LHS lvalue.
953
83
  if (LHSTy->isAnyComplexType()) {
954
79
    ComplexPairTy ResVal =
955
79
        EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy, Loc);
956
79
    EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false);
957
79
    Val = RValue::getComplex(ResVal);
958
79
  } else {
959
4
    llvm::Value *ResVal =
960
4
        CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy, Loc);
961
4
    CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false);
962
4
    Val = RValue::get(ResVal);
963
4
  }
964
965
83
  return LHS;
966
83
}
967
968
// Compound assignments.
969
ComplexPairTy ComplexExprEmitter::
970
EmitCompoundAssign(const CompoundAssignOperator *E,
971
15
                   ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
972
15
  RValue Val;
973
15
  LValue LV = EmitCompoundAssignLValue(E, Func, Val);
974
975
  // The result of an assignment in C is the assigned r-value.
976
15
  if (!CGF.getLangOpts().CPlusPlus)
977
13
    return Val.getComplexVal();
978
979
  // If the lvalue is non-volatile, return the computed value of the assignment.
980
2
  if (!LV.isVolatileQualified())
981
0
    return Val.getComplexVal();
982
983
2
  return EmitLoadOfLValue(LV, E->getExprLoc());
984
2
}
985
986
LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
987
206
                                               ComplexPairTy &Val) {
988
206
  assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
989
206
                                                 E->getRHS()->getType()) &&
990
206
         "Invalid assignment");
991
0
  TestAndClearIgnoreReal();
992
206
  TestAndClearIgnoreImag();
993
994
  // Emit the RHS.  __block variables need the RHS evaluated first.
995
206
  Val = Visit(E->getRHS());
996
997
  // Compute the address to store into.
998
206
  LValue LHS = CGF.EmitLValue(E->getLHS());
999
1000
  // Store the result value into the LHS lvalue.
1001
206
  EmitStoreOfComplex(Val, LHS, /*isInit*/ false);
1002
1003
206
  return LHS;
1004
206
}
1005
1006
175
ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
1007
175
  ComplexPairTy Val;
1008
175
  LValue LV = EmitBinAssignLValue(E, Val);
1009
1010
  // The result of an assignment in C is the assigned r-value.
1011
175
  if (!CGF.getLangOpts().CPlusPlus)
1012
169
    return Val;
1013
1014
  // If the lvalue is non-volatile, return the computed value of the assignment.
1015
6
  if (!LV.isVolatileQualified())
1016
0
    return Val;
1017
1018
6
  return EmitLoadOfLValue(LV, E->getExprLoc());
1019
6
}
1020
1021
0
ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
1022
0
  CGF.EmitIgnoredExpr(E->getLHS());
1023
0
  return Visit(E->getRHS());
1024
0
}
1025
1026
ComplexPairTy ComplexExprEmitter::
1027
11
VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
1028
11
  TestAndClearIgnoreReal();
1029
11
  TestAndClearIgnoreImag();
1030
11
  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
1031
11
  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
1032
11
  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
1033
1034
  // Bind the common expression if necessary.
1035
11
  CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1036
1037
1038
11
  CodeGenFunction::ConditionalEvaluation eval(CGF);
1039
11
  CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
1040
11
                           CGF.getProfileCount(E));
1041
1042
11
  eval.begin(CGF);
1043
11
  CGF.EmitBlock(LHSBlock);
1044
11
  CGF.incrementProfileCounter(E);
1045
11
  ComplexPairTy LHS = Visit(E->getTrueExpr());
1046
11
  LHSBlock = Builder.GetInsertBlock();
1047
11
  CGF.EmitBranch(ContBlock);
1048
11
  eval.end(CGF);
1049
1050
11
  eval.begin(CGF);
1051
11
  CGF.EmitBlock(RHSBlock);
1052
11
  ComplexPairTy RHS = Visit(E->getFalseExpr());
1053
11
  RHSBlock = Builder.GetInsertBlock();
1054
11
  CGF.EmitBlock(ContBlock);
1055
11
  eval.end(CGF);
1056
1057
  // Create a PHI node for the real part.
1058
11
  llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
1059
11
  RealPN->addIncoming(LHS.first, LHSBlock);
1060
11
  RealPN->addIncoming(RHS.first, RHSBlock);
1061
1062
  // Create a PHI node for the imaginary part.
1063
11
  llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
1064
11
  ImagPN->addIncoming(LHS.second, LHSBlock);
1065
11
  ImagPN->addIncoming(RHS.second, RHSBlock);
1066
1067
11
  return ComplexPairTy(RealPN, ImagPN);
1068
11
}
1069
1070
0
ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
1071
0
  return Visit(E->getChosenSubExpr());
1072
0
}
1073
1074
36
ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
1075
36
    bool Ignore = TestAndClearIgnoreReal();
1076
36
    (void)Ignore;
1077
36
    assert (Ignore == false && "init list ignored");
1078
0
    Ignore = TestAndClearIgnoreImag();
1079
36
    (void)Ignore;
1080
36
    assert (Ignore == false && "init list ignored");
1081
1082
36
  if (E->getNumInits() == 2) {
1083
18
    llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
1084
18
    llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
1085
18
    return ComplexPairTy(Real, Imag);
1086
18
  } else if (E->getNumInits() == 1) {
1087
2
    return Visit(E->getInit(0));
1088
2
  }
1089
1090
  // Empty init list initializes to null
1091
16
  assert(E->getNumInits() == 0 && "Unexpected number of inits");
1092
0
  QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
1093
16
  llvm::Type* LTy = CGF.ConvertType(Ty);
1094
16
  llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
1095
16
  return ComplexPairTy(zeroConstant, zeroConstant);
1096
36
}
1097
1098
29
ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
1099
29
  Address ArgValue = Address::invalid();
1100
29
  Address ArgPtr = CGF.EmitVAArg(E, ArgValue);
1101
1102
29
  if (!ArgPtr.isValid()) {
1103
0
    CGF.ErrorUnsupported(E, "complex va_arg expression");
1104
0
    llvm::Type *EltTy =
1105
0
      CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType());
1106
0
    llvm::Value *U = llvm::UndefValue::get(EltTy);
1107
0
    return ComplexPairTy(U, U);
1108
0
  }
1109
1110
29
  return EmitLoadOfLValue(CGF.MakeAddrLValue(ArgPtr, E->getType()),
1111
29
                          E->getExprLoc());
1112
29
}
1113
1114
//===----------------------------------------------------------------------===//
1115
//                         Entry Point into this File
1116
//===----------------------------------------------------------------------===//
1117
1118
/// EmitComplexExpr - Emit the computation of the specified expression of
1119
/// complex type, ignoring the result.
1120
ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
1121
1.37k
                                               bool IgnoreImag) {
1122
1.37k
  assert(E && getComplexType(E->getType()) &&
1123
1.37k
         "Invalid complex expression to emit");
1124
1125
0
  return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
1126
1.37k
      .Visit(const_cast<Expr *>(E));
1127
1.37k
}
1128
1129
void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
1130
740
                                                bool isInit) {
1131
740
  assert(E && getComplexType(E->getType()) &&
1132
740
         "Invalid complex expression to emit");
1133
0
  ComplexExprEmitter Emitter(*this);
1134
740
  ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
1135
740
  Emitter.EmitStoreOfComplex(Val, dest, isInit);
1136
740
}
1137
1138
/// EmitStoreOfComplex - Store a complex number into the specified l-value.
1139
void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
1140
941
                                         bool isInit) {
1141
941
  ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
1142
941
}
1143
1144
/// EmitLoadOfComplex - Load a complex number from the specified address.
1145
ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src,
1146
578
                                                 SourceLocation loc) {
1147
578
  return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc);
1148
578
}
1149
1150
31
LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
1151
31
  assert(E->getOpcode() == BO_Assign);
1152
0
  ComplexPairTy Val; // ignored
1153
31
  LValue LVal = ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
1154
31
  if (getLangOpts().OpenMP)
1155
4
    CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(*this,
1156
4
                                                              E->getLHS());
1157
31
  return LVal;
1158
31
}
1159
1160
typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)(
1161
    const ComplexExprEmitter::BinOpInfo &);
1162
1163
68
static CompoundFunc getComplexOp(BinaryOperatorKind Op) {
1164
68
  switch (Op) {
1165
58
  case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul;
1166
0
  case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv;
1167
0
  case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub;
1168
10
  case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd;
1169
0
  default:
1170
0
    llvm_unreachable("unexpected complex compound assignment");
1171
68
  }
1172
68
}
1173
1174
LValue CodeGenFunction::
1175
64
EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
1176
64
  CompoundFunc Op = getComplexOp(E->getOpcode());
1177
64
  RValue Val;
1178
64
  return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
1179
64
}
1180
1181
LValue CodeGenFunction::
1182
EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
1183
4
                                    llvm::Value *&Result) {
1184
4
  CompoundFunc Op = getComplexOp(E->getOpcode());
1185
4
  RValue Val;
1186
4
  LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
1187
4
  Result = Val.getScalarVal();
1188
4
  return Ret;
1189
4
}