Home | History | Annotate | Download | only in CodeGen 
      1 //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This contains code to emit Expr nodes with complex types as LLVM code.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "CodeGenFunction.h"
     15 #include "CodeGenModule.h"
     16 #include "clang/AST/ASTContext.h"
     17 #include "clang/AST/StmtVisitor.h"
     18 #include "llvm/ADT/SmallString.h"
     19 #include "llvm/IR/Constants.h"
     20 #include "llvm/IR/Function.h"
     21 #include <algorithm>
     22 using namespace clang;
     23 using namespace CodeGen;
     24 
     25 //===----------------------------------------------------------------------===//
     26 //                        Complex Expression Emitter
     27 //===----------------------------------------------------------------------===//
     28 
     29 typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
     30 
     31 /// Return the complex type that we are meant to emit.
     32 static const ComplexType *getComplexType(QualType type) {
     33   type = type.getCanonicalType();
     34   if (const ComplexType *comp = dyn_cast<ComplexType>(type)) {
     35     return comp;
     36   } else {
     37     return cast<ComplexType>(cast<AtomicType>(type)->getValueType());
     38   }
     39 }
     40 
     41 namespace  {
     42 class ComplexExprEmitter
     43   : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
     44   CodeGenFunction &CGF;
     45   CGBuilderTy &Builder;
     46   bool IgnoreReal;
     47   bool IgnoreImag;
     48 public:
     49   ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
     50     : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
     51   }
     52 
     53 
     54   //===--------------------------------------------------------------------===//
     55   //                               Utilities
     56   //===--------------------------------------------------------------------===//
     57 
     58   bool TestAndClearIgnoreReal() {
     59     bool I = IgnoreReal;
     60     IgnoreReal = false;
     61     return I;
     62   }
     63   bool TestAndClearIgnoreImag() {
     64     bool I = IgnoreImag;
     65     IgnoreImag = false;
     66     return I;
     67   }
     68 
     69   /// EmitLoadOfLValue - Given an expression with complex type that represents a
     70   /// value l-value, this method emits the address of the l-value, then loads
     71   /// and returns the result.
     72   ComplexPairTy EmitLoadOfLValue(const Expr *E) {
     73     return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc());
     74   }
     75 
     76   ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc);
     77 
     78   /// EmitStoreOfComplex - Store the specified real/imag parts into the
     79   /// specified value pointer.
     80   void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit);
     81 
     82   /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
     83   ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
     84                                          QualType DestType);
     85   /// EmitComplexToComplexCast - Emit a cast from scalar value Val to DestType.
     86   ComplexPairTy EmitScalarToComplexCast(llvm::Value *Val, QualType SrcType,
     87                                         QualType DestType);
     88 
     89   //===--------------------------------------------------------------------===//
     90   //                            Visitor Methods
     91   //===--------------------------------------------------------------------===//
     92 
     93   ComplexPairTy Visit(Expr *E) {
     94     return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
     95   }
     96 
     97   ComplexPairTy VisitStmt(Stmt *S) {
     98     S->dump(CGF.getContext().getSourceManager());
     99     llvm_unreachable("Stmt can't have complex result type!");
    100   }
    101   ComplexPairTy VisitExpr(Expr *S);
    102   ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
    103   ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
    104     return Visit(GE->getResultExpr());
    105   }
    106   ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
    107   ComplexPairTy
    108   VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
    109     return Visit(PE->getReplacement());
    110   }
    111 
    112   // l-values.
    113   ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) {
    114     if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) {
    115       if (result.isReference())
    116         return EmitLoadOfLValue(result.getReferenceLValue(CGF, E),
    117                                 E->getExprLoc());
    118 
    119       llvm::Constant *pair = result.getValue();
    120       return ComplexPairTy(pair->getAggregateElement(0U),
    121                            pair->getAggregateElement(1U));
    122     }
    123     return EmitLoadOfLValue(E);
    124   }
    125   ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
    126     return EmitLoadOfLValue(E);
    127   }
    128   ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
    129     return CGF.EmitObjCMessageExpr(E).getComplexVal();
    130   }
    131   ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
    132   ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); }
    133   ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
    134     if (E->isGLValue())
    135       return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->getExprLoc());
    136     return CGF.getOpaqueRValueMapping(E).getComplexVal();
    137   }
    138 
    139   ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) {
    140     return CGF.EmitPseudoObjectRValue(E).getComplexVal();
    141   }
    142 
    143   // FIXME: CompoundLiteralExpr
    144 
    145   ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy);
    146   ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
    147     // Unlike for scalars, we don't have to worry about function->ptr demotion
    148     // here.
    149     return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
    150   }
    151   ComplexPairTy VisitCastExpr(CastExpr *E) {
    152     return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
    153   }
    154   ComplexPairTy VisitCallExpr(const CallExpr *E);
    155   ComplexPairTy VisitStmtExpr(const StmtExpr *E);
    156 
    157   // Operators.
    158   ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
    159                                    bool isInc, bool isPre) {
    160     LValue LV = CGF.EmitLValue(E->getSubExpr());
    161     return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
    162   }
    163   ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
    164     return VisitPrePostIncDec(E, false, false);
    165   }
    166   ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
    167     return VisitPrePostIncDec(E, true, false);
    168   }
    169   ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
    170     return VisitPrePostIncDec(E, false, true);
    171   }
    172   ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
    173     return VisitPrePostIncDec(E, true, true);
    174   }
    175   ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
    176   ComplexPairTy VisitUnaryPlus     (const UnaryOperator *E) {
    177     TestAndClearIgnoreReal();
    178     TestAndClearIgnoreImag();
    179     return Visit(E->getSubExpr());
    180   }
    181   ComplexPairTy VisitUnaryMinus    (const UnaryOperator *E);
    182   ComplexPairTy VisitUnaryNot      (const UnaryOperator *E);
    183   // LNot,Real,Imag never return complex.
    184   ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
    185     return Visit(E->getSubExpr());
    186   }
    187   ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
    188     return Visit(DAE->getExpr());
    189   }
    190   ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
    191     CodeGenFunction::CXXDefaultInitExprScope Scope(CGF);
    192     return Visit(DIE->getExpr());
    193   }
    194   ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
    195     CGF.enterFullExpression(E);
    196     CodeGenFunction::RunCleanupsScope Scope(CGF);
    197     return Visit(E->getSubExpr());
    198   }
    199   ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
    200     assert(E->getType()->isAnyComplexType() && "Expected complex type!");
    201     QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
    202     llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
    203     return ComplexPairTy(Null, Null);
    204   }
    205   ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
    206     assert(E->getType()->isAnyComplexType() && "Expected complex type!");
    207     QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
    208     llvm::Constant *Null =
    209                        llvm::Constant::getNullValue(CGF.ConvertType(Elem));
    210     return ComplexPairTy(Null, Null);
    211   }
    212 
    213   struct BinOpInfo {
    214     ComplexPairTy LHS;
    215     ComplexPairTy RHS;
    216     QualType Ty;  // Computation Type.
    217   };
    218 
    219   BinOpInfo EmitBinOps(const BinaryOperator *E);
    220   LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
    221                                   ComplexPairTy (ComplexExprEmitter::*Func)
    222                                   (const BinOpInfo &),
    223                                   RValue &Val);
    224   ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
    225                                    ComplexPairTy (ComplexExprEmitter::*Func)
    226                                    (const BinOpInfo &));
    227 
    228   ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
    229   ComplexPairTy EmitBinSub(const BinOpInfo &Op);
    230   ComplexPairTy EmitBinMul(const BinOpInfo &Op);
    231   ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
    232 
    233   ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
    234     return EmitBinAdd(EmitBinOps(E));
    235   }
    236   ComplexPairTy VisitBinSub(const BinaryOperator *E) {
    237     return EmitBinSub(EmitBinOps(E));
    238   }
    239   ComplexPairTy VisitBinMul(const BinaryOperator *E) {
    240     return EmitBinMul(EmitBinOps(E));
    241   }
    242   ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
    243     return EmitBinDiv(EmitBinOps(E));
    244   }
    245 
    246   // Compound assignments.
    247   ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
    248     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
    249   }
    250   ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
    251     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
    252   }
    253   ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
    254     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
    255   }
    256   ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
    257     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
    258   }
    259 
    260   // GCC rejects rem/and/or/xor for integer complex.
    261   // Logical and/or always return int, never complex.
    262 
    263   // No comparisons produce a complex result.
    264 
    265   LValue EmitBinAssignLValue(const BinaryOperator *E,
    266                              ComplexPairTy &Val);
    267   ComplexPairTy VisitBinAssign     (const BinaryOperator *E);
    268   ComplexPairTy VisitBinComma      (const BinaryOperator *E);
    269 
    270 
    271   ComplexPairTy
    272   VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
    273   ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
    274 
    275   ComplexPairTy VisitInitListExpr(InitListExpr *E);
    276 
    277   ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
    278     return EmitLoadOfLValue(E);
    279   }
    280 
    281   ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
    282 
    283   ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
    284     return CGF.EmitAtomicExpr(E).getComplexVal();
    285   }
    286 };
    287 }  // end anonymous namespace.
    288 
    289 //===----------------------------------------------------------------------===//
    290 //                                Utilities
    291 //===----------------------------------------------------------------------===//
    292 
    293 /// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to
    294 /// load the real and imaginary pieces, returning them as Real/Imag.
    295 ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue,
    296                                                    SourceLocation loc) {
    297   assert(lvalue.isSimple() && "non-simple complex l-value?");
    298   if (lvalue.getType()->isAtomicType())
    299     return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal();
    300 
    301   llvm::Value *SrcPtr = lvalue.getAddress();
    302   bool isVolatile = lvalue.isVolatileQualified();
    303   unsigned AlignR = lvalue.getAlignment().getQuantity();
    304   ASTContext &C = CGF.getContext();
    305   QualType ComplexTy = lvalue.getType();
    306   unsigned ComplexAlign = C.getTypeAlignInChars(ComplexTy).getQuantity();
    307   unsigned AlignI = std::min(AlignR, ComplexAlign);
    308 
    309   llvm::Value *Real=nullptr, *Imag=nullptr;
    310 
    311   if (!IgnoreReal || isVolatile) {
    312     llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
    313                                                  SrcPtr->getName() + ".realp");
    314     Real = Builder.CreateAlignedLoad(RealP, AlignR, isVolatile,
    315                                      SrcPtr->getName() + ".real");
    316   }
    317 
    318   if (!IgnoreImag || isVolatile) {
    319     llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
    320                                                  SrcPtr->getName() + ".imagp");
    321     Imag = Builder.CreateAlignedLoad(ImagP, AlignI, isVolatile,
    322                                      SrcPtr->getName() + ".imag");
    323   }
    324   return ComplexPairTy(Real, Imag);
    325 }
    326 
    327 /// EmitStoreOfComplex - Store the specified real/imag parts into the
    328 /// specified value pointer.
    329 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val,
    330                                             LValue lvalue,
    331                                             bool isInit) {
    332   if (lvalue.getType()->isAtomicType())
    333     return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit);
    334 
    335   llvm::Value *Ptr = lvalue.getAddress();
    336   llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
    337   llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
    338   unsigned AlignR = lvalue.getAlignment().getQuantity();
    339   ASTContext &C = CGF.getContext();
    340   QualType ComplexTy = lvalue.getType();
    341   unsigned ComplexAlign = C.getTypeAlignInChars(ComplexTy).getQuantity();
    342   unsigned AlignI = std::min(AlignR, ComplexAlign);
    343 
    344   Builder.CreateAlignedStore(Val.first, RealPtr, AlignR,
    345                              lvalue.isVolatileQualified());
    346   Builder.CreateAlignedStore(Val.second, ImagPtr, AlignI,
    347                              lvalue.isVolatileQualified());
    348 }
    349 
    350 
    351 
    352 //===----------------------------------------------------------------------===//
    353 //                            Visitor Methods
    354 //===----------------------------------------------------------------------===//
    355 
    356 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
    357   CGF.ErrorUnsupported(E, "complex expression");
    358   llvm::Type *EltTy =
    359     CGF.ConvertType(getComplexType(E->getType())->getElementType());
    360   llvm::Value *U = llvm::UndefValue::get(EltTy);
    361   return ComplexPairTy(U, U);
    362 }
    363 
    364 ComplexPairTy ComplexExprEmitter::
    365 VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
    366   llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
    367   return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
    368 }
    369 
    370 
    371 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
    372   if (E->getCallReturnType()->isReferenceType())
    373     return EmitLoadOfLValue(E);
    374 
    375   return CGF.EmitCallExpr(E).getComplexVal();
    376 }
    377 
    378 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
    379   CodeGenFunction::StmtExprEvaluation eval(CGF);
    380   llvm::Value *RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true);
    381   assert(RetAlloca && "Expected complex return value");
    382   return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()),
    383                           E->getExprLoc());
    384 }
    385 
    386 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
    387 ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
    388                                                            QualType SrcType,
    389                                                            QualType DestType) {
    390   // Get the src/dest element type.
    391   SrcType = SrcType->castAs<ComplexType>()->getElementType();
    392   DestType = DestType->castAs<ComplexType>()->getElementType();
    393 
    394   // C99 6.3.1.6: When a value of complex type is converted to another
    395   // complex type, both the real and imaginary parts follow the conversion
    396   // rules for the corresponding real types.
    397   Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
    398   Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
    399   return Val;
    400 }
    401 
    402 ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val,
    403                                                           QualType SrcType,
    404                                                           QualType DestType) {
    405   // Convert the input element to the element type of the complex.
    406   DestType = DestType->castAs<ComplexType>()->getElementType();
    407   Val = CGF.EmitScalarConversion(Val, SrcType, DestType);
    408 
    409   // Return (realval, 0).
    410   return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType()));
    411 }
    412 
    413 ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op,
    414                                            QualType DestTy) {
    415   switch (CK) {
    416   case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
    417 
    418   // Atomic to non-atomic casts may be more than a no-op for some platforms and
    419   // for some types.
    420   case CK_AtomicToNonAtomic:
    421   case CK_NonAtomicToAtomic:
    422   case CK_NoOp:
    423   case CK_LValueToRValue:
    424   case CK_UserDefinedConversion:
    425     return Visit(Op);
    426 
    427   case CK_LValueBitCast: {
    428     LValue origLV = CGF.EmitLValue(Op);
    429     llvm::Value *V = origLV.getAddress();
    430     V = Builder.CreateBitCast(V,
    431                     CGF.ConvertType(CGF.getContext().getPointerType(DestTy)));
    432     return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy,
    433                                                origLV.getAlignment()),
    434                             Op->getExprLoc());
    435   }
    436 
    437   case CK_BitCast:
    438   case CK_BaseToDerived:
    439   case CK_DerivedToBase:
    440   case CK_UncheckedDerivedToBase:
    441   case CK_Dynamic:
    442   case CK_ToUnion:
    443   case CK_ArrayToPointerDecay:
    444   case CK_FunctionToPointerDecay:
    445   case CK_NullToPointer:
    446   case CK_NullToMemberPointer:
    447   case CK_BaseToDerivedMemberPointer:
    448   case CK_DerivedToBaseMemberPointer:
    449   case CK_MemberPointerToBoolean:
    450   case CK_ReinterpretMemberPointer:
    451   case CK_ConstructorConversion:
    452   case CK_IntegralToPointer:
    453   case CK_PointerToIntegral:
    454   case CK_PointerToBoolean:
    455   case CK_ToVoid:
    456   case CK_VectorSplat:
    457   case CK_IntegralCast:
    458   case CK_IntegralToBoolean:
    459   case CK_IntegralToFloating:
    460   case CK_FloatingToIntegral:
    461   case CK_FloatingToBoolean:
    462   case CK_FloatingCast:
    463   case CK_CPointerToObjCPointerCast:
    464   case CK_BlockPointerToObjCPointerCast:
    465   case CK_AnyPointerToBlockPointerCast:
    466   case CK_ObjCObjectLValueCast:
    467   case CK_FloatingComplexToReal:
    468   case CK_FloatingComplexToBoolean:
    469   case CK_IntegralComplexToReal:
    470   case CK_IntegralComplexToBoolean:
    471   case CK_ARCProduceObject:
    472   case CK_ARCConsumeObject:
    473   case CK_ARCReclaimReturnedObject:
    474   case CK_ARCExtendBlockObject:
    475   case CK_CopyAndAutoreleaseBlockObject:
    476   case CK_BuiltinFnToFnPtr:
    477   case CK_ZeroToOCLEvent:
    478   case CK_AddressSpaceConversion:
    479     llvm_unreachable("invalid cast kind for complex value");
    480 
    481   case CK_FloatingRealToComplex:
    482   case CK_IntegralRealToComplex:
    483     return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op),
    484                                    Op->getType(), DestTy);
    485 
    486   case CK_FloatingComplexCast:
    487   case CK_FloatingComplexToIntegralComplex:
    488   case CK_IntegralComplexCast:
    489   case CK_IntegralComplexToFloatingComplex:
    490     return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
    491   }
    492 
    493   llvm_unreachable("unknown cast resulting in complex value");
    494 }
    495 
    496 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
    497   TestAndClearIgnoreReal();
    498   TestAndClearIgnoreImag();
    499   ComplexPairTy Op = Visit(E->getSubExpr());
    500 
    501   llvm::Value *ResR, *ResI;
    502   if (Op.first->getType()->isFloatingPointTy()) {
    503     ResR = Builder.CreateFNeg(Op.first,  "neg.r");
    504     ResI = Builder.CreateFNeg(Op.second, "neg.i");
    505   } else {
    506     ResR = Builder.CreateNeg(Op.first,  "neg.r");
    507     ResI = Builder.CreateNeg(Op.second, "neg.i");
    508   }
    509   return ComplexPairTy(ResR, ResI);
    510 }
    511 
    512 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
    513   TestAndClearIgnoreReal();
    514   TestAndClearIgnoreImag();
    515   // ~(a+ib) = a + i*-b
    516   ComplexPairTy Op = Visit(E->getSubExpr());
    517   llvm::Value *ResI;
    518   if (Op.second->getType()->isFloatingPointTy())
    519     ResI = Builder.CreateFNeg(Op.second, "conj.i");
    520   else
    521     ResI = Builder.CreateNeg(Op.second, "conj.i");
    522 
    523   return ComplexPairTy(Op.first, ResI);
    524 }
    525 
    526 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
    527   llvm::Value *ResR, *ResI;
    528 
    529   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    530     ResR = Builder.CreateFAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
    531     ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
    532   } else {
    533     ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
    534     ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
    535   }
    536   return ComplexPairTy(ResR, ResI);
    537 }
    538 
    539 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
    540   llvm::Value *ResR, *ResI;
    541   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    542     ResR = Builder.CreateFSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
    543     ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
    544   } else {
    545     ResR = Builder.CreateSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
    546     ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
    547   }
    548   return ComplexPairTy(ResR, ResI);
    549 }
    550 
    551 
    552 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
    553   using llvm::Value;
    554   Value *ResR, *ResI;
    555 
    556   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    557     Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
    558     Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
    559     ResR  = Builder.CreateFSub(ResRl, ResRr, "mul.r");
    560 
    561     Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
    562     Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
    563     ResI  = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
    564   } else {
    565     Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
    566     Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
    567     ResR  = Builder.CreateSub(ResRl, ResRr, "mul.r");
    568 
    569     Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
    570     Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
    571     ResI  = Builder.CreateAdd(ResIl, ResIr, "mul.i");
    572   }
    573   return ComplexPairTy(ResR, ResI);
    574 }
    575 
    576 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
    577   llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
    578   llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
    579 
    580 
    581   llvm::Value *DSTr, *DSTi;
    582   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    583     // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
    584     llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c
    585     llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d
    586     llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd
    587 
    588     llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c
    589     llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d
    590     llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd
    591 
    592     llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c
    593     llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d
    594     llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad
    595 
    596     DSTr = Builder.CreateFDiv(Tmp3, Tmp6);
    597     DSTi = Builder.CreateFDiv(Tmp9, Tmp6);
    598   } else {
    599     // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
    600     llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
    601     llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
    602     llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
    603 
    604     llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
    605     llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
    606     llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
    607 
    608     llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
    609     llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
    610     llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
    611 
    612     if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
    613       DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
    614       DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
    615     } else {
    616       DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
    617       DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
    618     }
    619   }
    620 
    621   return ComplexPairTy(DSTr, DSTi);
    622 }
    623 
    624 ComplexExprEmitter::BinOpInfo
    625 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
    626   TestAndClearIgnoreReal();
    627   TestAndClearIgnoreImag();
    628   BinOpInfo Ops;
    629   Ops.LHS = Visit(E->getLHS());
    630   Ops.RHS = Visit(E->getRHS());
    631   Ops.Ty = E->getType();
    632   return Ops;
    633 }
    634 
    635 
    636 LValue ComplexExprEmitter::
    637 EmitCompoundAssignLValue(const CompoundAssignOperator *E,
    638           ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
    639                          RValue &Val) {
    640   TestAndClearIgnoreReal();
    641   TestAndClearIgnoreImag();
    642   QualType LHSTy = E->getLHS()->getType();
    643 
    644   BinOpInfo OpInfo;
    645 
    646   // Load the RHS and LHS operands.
    647   // __block variables need to have the rhs evaluated first, plus this should
    648   // improve codegen a little.
    649   OpInfo.Ty = E->getComputationResultType();
    650 
    651   // The RHS should have been converted to the computation type.
    652   assert(OpInfo.Ty->isAnyComplexType());
    653   assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
    654                                                  E->getRHS()->getType()));
    655   OpInfo.RHS = Visit(E->getRHS());
    656 
    657   LValue LHS = CGF.EmitLValue(E->getLHS());
    658 
    659   // Load from the l-value and convert it.
    660   if (LHSTy->isAnyComplexType()) {
    661     ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, E->getExprLoc());
    662     OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty);
    663   } else {
    664     llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, E->getExprLoc());
    665     OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty);
    666   }
    667 
    668   // Expand the binary operator.
    669   ComplexPairTy Result = (this->*Func)(OpInfo);
    670 
    671   // Truncate the result and store it into the LHS lvalue.
    672   if (LHSTy->isAnyComplexType()) {
    673     ComplexPairTy ResVal = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
    674     EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false);
    675     Val = RValue::getComplex(ResVal);
    676   } else {
    677     llvm::Value *ResVal =
    678         CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy);
    679     CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false);
    680     Val = RValue::get(ResVal);
    681   }
    682 
    683   return LHS;
    684 }
    685 
    686 // Compound assignments.
    687 ComplexPairTy ComplexExprEmitter::
    688 EmitCompoundAssign(const CompoundAssignOperator *E,
    689                    ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
    690   RValue Val;
    691   LValue LV = EmitCompoundAssignLValue(E, Func, Val);
    692 
    693   // The result of an assignment in C is the assigned r-value.
    694   if (!CGF.getLangOpts().CPlusPlus)
    695     return Val.getComplexVal();
    696 
    697   // If the lvalue is non-volatile, return the computed value of the assignment.
    698   if (!LV.isVolatileQualified())
    699     return Val.getComplexVal();
    700 
    701   return EmitLoadOfLValue(LV, E->getExprLoc());
    702 }
    703 
    704 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
    705                                                ComplexPairTy &Val) {
    706   assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
    707                                                  E->getRHS()->getType()) &&
    708          "Invalid assignment");
    709   TestAndClearIgnoreReal();
    710   TestAndClearIgnoreImag();
    711 
    712   // Emit the RHS.  __block variables need the RHS evaluated first.
    713   Val = Visit(E->getRHS());
    714 
    715   // Compute the address to store into.
    716   LValue LHS = CGF.EmitLValue(E->getLHS());
    717 
    718   // Store the result value into the LHS lvalue.
    719   EmitStoreOfComplex(Val, LHS, /*isInit*/ false);
    720 
    721   return LHS;
    722 }
    723 
    724 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
    725   ComplexPairTy Val;
    726   LValue LV = EmitBinAssignLValue(E, Val);
    727 
    728   // The result of an assignment in C is the assigned r-value.
    729   if (!CGF.getLangOpts().CPlusPlus)
    730     return Val;
    731 
    732   // If the lvalue is non-volatile, return the computed value of the assignment.
    733   if (!LV.isVolatileQualified())
    734     return Val;
    735 
    736   return EmitLoadOfLValue(LV, E->getExprLoc());
    737 }
    738 
    739 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
    740   CGF.EmitIgnoredExpr(E->getLHS());
    741   return Visit(E->getRHS());
    742 }
    743 
    744 ComplexPairTy ComplexExprEmitter::
    745 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
    746   TestAndClearIgnoreReal();
    747   TestAndClearIgnoreImag();
    748   llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
    749   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
    750   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
    751 
    752   // Bind the common expression if necessary.
    753   CodeGenFunction::OpaqueValueMapping binding(CGF, E);
    754 
    755   RegionCounter Cnt = CGF.getPGORegionCounter(E);
    756   CodeGenFunction::ConditionalEvaluation eval(CGF);
    757   CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, Cnt.getCount());
    758 
    759   eval.begin(CGF);
    760   CGF.EmitBlock(LHSBlock);
    761   Cnt.beginRegion(Builder);
    762   ComplexPairTy LHS = Visit(E->getTrueExpr());
    763   LHSBlock = Builder.GetInsertBlock();
    764   CGF.EmitBranch(ContBlock);
    765   eval.end(CGF);
    766 
    767   eval.begin(CGF);
    768   CGF.EmitBlock(RHSBlock);
    769   ComplexPairTy RHS = Visit(E->getFalseExpr());
    770   RHSBlock = Builder.GetInsertBlock();
    771   CGF.EmitBlock(ContBlock);
    772   eval.end(CGF);
    773 
    774   // Create a PHI node for the real part.
    775   llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
    776   RealPN->addIncoming(LHS.first, LHSBlock);
    777   RealPN->addIncoming(RHS.first, RHSBlock);
    778 
    779   // Create a PHI node for the imaginary part.
    780   llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
    781   ImagPN->addIncoming(LHS.second, LHSBlock);
    782   ImagPN->addIncoming(RHS.second, RHSBlock);
    783 
    784   return ComplexPairTy(RealPN, ImagPN);
    785 }
    786 
    787 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
    788   return Visit(E->getChosenSubExpr());
    789 }
    790 
    791 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
    792     bool Ignore = TestAndClearIgnoreReal();
    793     (void)Ignore;
    794     assert (Ignore == false && "init list ignored");
    795     Ignore = TestAndClearIgnoreImag();
    796     (void)Ignore;
    797     assert (Ignore == false && "init list ignored");
    798 
    799   if (E->getNumInits() == 2) {
    800     llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
    801     llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
    802     return ComplexPairTy(Real, Imag);
    803   } else if (E->getNumInits() == 1) {
    804     return Visit(E->getInit(0));
    805   }
    806 
    807   // Empty init list intializes to null
    808   assert(E->getNumInits() == 0 && "Unexpected number of inits");
    809   QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
    810   llvm::Type* LTy = CGF.ConvertType(Ty);
    811   llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
    812   return ComplexPairTy(zeroConstant, zeroConstant);
    813 }
    814 
    815 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
    816   llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
    817   llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
    818 
    819   if (!ArgPtr) {
    820     CGF.ErrorUnsupported(E, "complex va_arg expression");
    821     llvm::Type *EltTy =
    822       CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType());
    823     llvm::Value *U = llvm::UndefValue::get(EltTy);
    824     return ComplexPairTy(U, U);
    825   }
    826 
    827   return EmitLoadOfLValue(CGF.MakeNaturalAlignAddrLValue(ArgPtr, E->getType()),
    828                           E->getExprLoc());
    829 }
    830 
    831 //===----------------------------------------------------------------------===//
    832 //                         Entry Point into this File
    833 //===----------------------------------------------------------------------===//
    834 
    835 /// EmitComplexExpr - Emit the computation of the specified expression of
    836 /// complex type, ignoring the result.
    837 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
    838                                                bool IgnoreImag) {
    839   assert(E && getComplexType(E->getType()) &&
    840          "Invalid complex expression to emit");
    841 
    842   return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
    843     .Visit(const_cast<Expr*>(E));
    844 }
    845 
    846 void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
    847                                                 bool isInit) {
    848   assert(E && getComplexType(E->getType()) &&
    849          "Invalid complex expression to emit");
    850   ComplexExprEmitter Emitter(*this);
    851   ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
    852   Emitter.EmitStoreOfComplex(Val, dest, isInit);
    853 }
    854 
    855 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
    856 void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
    857                                          bool isInit) {
    858   ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
    859 }
    860 
    861 /// EmitLoadOfComplex - Load a complex number from the specified address.
    862 ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src,
    863                                                  SourceLocation loc) {
    864   return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc);
    865 }
    866 
    867 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
    868   assert(E->getOpcode() == BO_Assign);
    869   ComplexPairTy Val; // ignored
    870   return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
    871 }
    872 
    873 typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)(
    874     const ComplexExprEmitter::BinOpInfo &);
    875 
    876 static CompoundFunc getComplexOp(BinaryOperatorKind Op) {
    877   switch (Op) {
    878   case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul;
    879   case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv;
    880   case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub;
    881   case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd;
    882   default:
    883     llvm_unreachable("unexpected complex compound assignment");
    884   }
    885 }
    886 
    887 LValue CodeGenFunction::
    888 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
    889   CompoundFunc Op = getComplexOp(E->getOpcode());
    890   RValue Val;
    891   return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
    892 }
    893 
    894 LValue CodeGenFunction::
    895 EmitScalarCompooundAssignWithComplex(const CompoundAssignOperator *E,
    896                                      llvm::Value *&Result) {
    897   CompoundFunc Op = getComplexOp(E->getOpcode());
    898   RValue Val;
    899   LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
    900   Result = Val.getScalarVal();
    901   return Ret;
    902 }
    903