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