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