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   case CK_BuiltinFnToFnPtr:
    431     llvm_unreachable("invalid cast kind for complex value");
    432 
    433   case CK_FloatingRealToComplex:
    434   case CK_IntegralRealToComplex: {
    435     llvm::Value *Elt = CGF.EmitScalarExpr(Op);
    436 
    437     // Convert the input element to the element type of the complex.
    438     DestTy = DestTy->getAs<ComplexType>()->getElementType();
    439     Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
    440 
    441     // Return (realval, 0).
    442     return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
    443   }
    444 
    445   case CK_FloatingComplexCast:
    446   case CK_FloatingComplexToIntegralComplex:
    447   case CK_IntegralComplexCast:
    448   case CK_IntegralComplexToFloatingComplex:
    449     return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
    450   }
    451 
    452   llvm_unreachable("unknown cast resulting in complex value");
    453 }
    454 
    455 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
    456   TestAndClearIgnoreReal();
    457   TestAndClearIgnoreImag();
    458   ComplexPairTy Op = Visit(E->getSubExpr());
    459 
    460   llvm::Value *ResR, *ResI;
    461   if (Op.first->getType()->isFloatingPointTy()) {
    462     ResR = Builder.CreateFNeg(Op.first,  "neg.r");
    463     ResI = Builder.CreateFNeg(Op.second, "neg.i");
    464   } else {
    465     ResR = Builder.CreateNeg(Op.first,  "neg.r");
    466     ResI = Builder.CreateNeg(Op.second, "neg.i");
    467   }
    468   return ComplexPairTy(ResR, ResI);
    469 }
    470 
    471 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
    472   TestAndClearIgnoreReal();
    473   TestAndClearIgnoreImag();
    474   // ~(a+ib) = a + i*-b
    475   ComplexPairTy Op = Visit(E->getSubExpr());
    476   llvm::Value *ResI;
    477   if (Op.second->getType()->isFloatingPointTy())
    478     ResI = Builder.CreateFNeg(Op.second, "conj.i");
    479   else
    480     ResI = Builder.CreateNeg(Op.second, "conj.i");
    481 
    482   return ComplexPairTy(Op.first, ResI);
    483 }
    484 
    485 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
    486   llvm::Value *ResR, *ResI;
    487 
    488   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    489     ResR = Builder.CreateFAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
    490     ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
    491   } else {
    492     ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
    493     ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
    494   }
    495   return ComplexPairTy(ResR, ResI);
    496 }
    497 
    498 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
    499   llvm::Value *ResR, *ResI;
    500   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    501     ResR = Builder.CreateFSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
    502     ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
    503   } else {
    504     ResR = Builder.CreateSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
    505     ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
    506   }
    507   return ComplexPairTy(ResR, ResI);
    508 }
    509 
    510 
    511 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
    512   using llvm::Value;
    513   Value *ResR, *ResI;
    514 
    515   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    516     Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
    517     Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
    518     ResR  = Builder.CreateFSub(ResRl, ResRr, "mul.r");
    519 
    520     Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
    521     Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
    522     ResI  = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
    523   } else {
    524     Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
    525     Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
    526     ResR  = Builder.CreateSub(ResRl, ResRr, "mul.r");
    527 
    528     Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
    529     Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
    530     ResI  = Builder.CreateAdd(ResIl, ResIr, "mul.i");
    531   }
    532   return ComplexPairTy(ResR, ResI);
    533 }
    534 
    535 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
    536   llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
    537   llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
    538 
    539 
    540   llvm::Value *DSTr, *DSTi;
    541   if (Op.LHS.first->getType()->isFloatingPointTy()) {
    542     // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
    543     llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c
    544     llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d
    545     llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd
    546 
    547     llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c
    548     llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d
    549     llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd
    550 
    551     llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c
    552     llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d
    553     llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad
    554 
    555     DSTr = Builder.CreateFDiv(Tmp3, Tmp6);
    556     DSTi = Builder.CreateFDiv(Tmp9, Tmp6);
    557   } else {
    558     // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
    559     llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
    560     llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
    561     llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
    562 
    563     llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
    564     llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
    565     llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
    566 
    567     llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
    568     llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
    569     llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
    570 
    571     if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
    572       DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
    573       DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
    574     } else {
    575       DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
    576       DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
    577     }
    578   }
    579 
    580   return ComplexPairTy(DSTr, DSTi);
    581 }
    582 
    583 ComplexExprEmitter::BinOpInfo
    584 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
    585   TestAndClearIgnoreReal();
    586   TestAndClearIgnoreImag();
    587   BinOpInfo Ops;
    588   Ops.LHS = Visit(E->getLHS());
    589   Ops.RHS = Visit(E->getRHS());
    590   Ops.Ty = E->getType();
    591   return Ops;
    592 }
    593 
    594 
    595 LValue ComplexExprEmitter::
    596 EmitCompoundAssignLValue(const CompoundAssignOperator *E,
    597           ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
    598                          ComplexPairTy &Val) {
    599   TestAndClearIgnoreReal();
    600   TestAndClearIgnoreImag();
    601   QualType LHSTy = E->getLHS()->getType();
    602 
    603   BinOpInfo OpInfo;
    604 
    605   // Load the RHS and LHS operands.
    606   // __block variables need to have the rhs evaluated first, plus this should
    607   // improve codegen a little.
    608   OpInfo.Ty = E->getComputationResultType();
    609 
    610   // The RHS should have been converted to the computation type.
    611   assert(OpInfo.Ty->isAnyComplexType());
    612   assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
    613                                                  E->getRHS()->getType()));
    614   OpInfo.RHS = Visit(E->getRHS());
    615 
    616   LValue LHS = CGF.EmitLValue(E->getLHS());
    617 
    618   // Load from the l-value.
    619   ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS);
    620 
    621   OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty);
    622 
    623   // Expand the binary operator.
    624   ComplexPairTy Result = (this->*Func)(OpInfo);
    625 
    626   // Truncate the result back to the LHS type.
    627   Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
    628   Val = Result;
    629 
    630   // Store the result value into the LHS lvalue.
    631   EmitStoreThroughLValue(Result, LHS);
    632 
    633   return LHS;
    634 }
    635 
    636 // Compound assignments.
    637 ComplexPairTy ComplexExprEmitter::
    638 EmitCompoundAssign(const CompoundAssignOperator *E,
    639                    ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
    640   ComplexPairTy Val;
    641   LValue LV = EmitCompoundAssignLValue(E, Func, Val);
    642 
    643   // The result of an assignment in C is the assigned r-value.
    644   if (!CGF.getContext().getLangOpts().CPlusPlus)
    645     return Val;
    646 
    647   // If the lvalue is non-volatile, return the computed value of the assignment.
    648   if (!LV.isVolatileQualified())
    649     return Val;
    650 
    651   return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
    652 }
    653 
    654 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
    655                                                ComplexPairTy &Val) {
    656   assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
    657                                                  E->getRHS()->getType()) &&
    658          "Invalid assignment");
    659   TestAndClearIgnoreReal();
    660   TestAndClearIgnoreImag();
    661 
    662   // Emit the RHS.  __block variables need the RHS evaluated first.
    663   Val = Visit(E->getRHS());
    664 
    665   // Compute the address to store into.
    666   LValue LHS = CGF.EmitLValue(E->getLHS());
    667 
    668   // Store the result value into the LHS lvalue.
    669   EmitStoreThroughLValue(Val, LHS);
    670 
    671   return LHS;
    672 }
    673 
    674 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
    675   ComplexPairTy Val;
    676   LValue LV = EmitBinAssignLValue(E, Val);
    677 
    678   // The result of an assignment in C is the assigned r-value.
    679   if (!CGF.getContext().getLangOpts().CPlusPlus)
    680     return Val;
    681 
    682   // If the lvalue is non-volatile, return the computed value of the assignment.
    683   if (!LV.isVolatileQualified())
    684     return Val;
    685 
    686   return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
    687 }
    688 
    689 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
    690   CGF.EmitIgnoredExpr(E->getLHS());
    691   return Visit(E->getRHS());
    692 }
    693 
    694 ComplexPairTy ComplexExprEmitter::
    695 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
    696   TestAndClearIgnoreReal();
    697   TestAndClearIgnoreImag();
    698   llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
    699   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
    700   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
    701 
    702   // Bind the common expression if necessary.
    703   CodeGenFunction::OpaqueValueMapping binding(CGF, E);
    704 
    705   CodeGenFunction::ConditionalEvaluation eval(CGF);
    706   CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
    707 
    708   eval.begin(CGF);
    709   CGF.EmitBlock(LHSBlock);
    710   ComplexPairTy LHS = Visit(E->getTrueExpr());
    711   LHSBlock = Builder.GetInsertBlock();
    712   CGF.EmitBranch(ContBlock);
    713   eval.end(CGF);
    714 
    715   eval.begin(CGF);
    716   CGF.EmitBlock(RHSBlock);
    717   ComplexPairTy RHS = Visit(E->getFalseExpr());
    718   RHSBlock = Builder.GetInsertBlock();
    719   CGF.EmitBlock(ContBlock);
    720   eval.end(CGF);
    721 
    722   // Create a PHI node for the real part.
    723   llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
    724   RealPN->addIncoming(LHS.first, LHSBlock);
    725   RealPN->addIncoming(RHS.first, RHSBlock);
    726 
    727   // Create a PHI node for the imaginary part.
    728   llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
    729   ImagPN->addIncoming(LHS.second, LHSBlock);
    730   ImagPN->addIncoming(RHS.second, RHSBlock);
    731 
    732   return ComplexPairTy(RealPN, ImagPN);
    733 }
    734 
    735 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
    736   return Visit(E->getChosenSubExpr(CGF.getContext()));
    737 }
    738 
    739 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
    740     bool Ignore = TestAndClearIgnoreReal();
    741     (void)Ignore;
    742     assert (Ignore == false && "init list ignored");
    743     Ignore = TestAndClearIgnoreImag();
    744     (void)Ignore;
    745     assert (Ignore == false && "init list ignored");
    746 
    747   if (E->getNumInits() == 2) {
    748     llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
    749     llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
    750     return ComplexPairTy(Real, Imag);
    751   } else if (E->getNumInits() == 1) {
    752     return Visit(E->getInit(0));
    753   }
    754 
    755   // Empty init list intializes to null
    756   assert(E->getNumInits() == 0 && "Unexpected number of inits");
    757   QualType Ty = E->getType()->getAs<ComplexType>()->getElementType();
    758   llvm::Type* LTy = CGF.ConvertType(Ty);
    759   llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
    760   return ComplexPairTy(zeroConstant, zeroConstant);
    761 }
    762 
    763 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
    764   llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
    765   llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
    766 
    767   if (!ArgPtr) {
    768     CGF.ErrorUnsupported(E, "complex va_arg expression");
    769     llvm::Type *EltTy =
    770       CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
    771     llvm::Value *U = llvm::UndefValue::get(EltTy);
    772     return ComplexPairTy(U, U);
    773   }
    774 
    775   // FIXME Volatility.
    776   return EmitLoadOfComplex(ArgPtr, false);
    777 }
    778 
    779 //===----------------------------------------------------------------------===//
    780 //                         Entry Point into this File
    781 //===----------------------------------------------------------------------===//
    782 
    783 /// EmitComplexExpr - Emit the computation of the specified expression of
    784 /// complex type, ignoring the result.
    785 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
    786                                                bool IgnoreImag) {
    787   assert(E && E->getType()->isAnyComplexType() &&
    788          "Invalid complex expression to emit");
    789 
    790   return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
    791     .Visit(const_cast<Expr*>(E));
    792 }
    793 
    794 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
    795 /// of complex type, storing into the specified Value*.
    796 void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E,
    797                                               llvm::Value *DestAddr,
    798                                               bool DestIsVolatile) {
    799   assert(E && E->getType()->isAnyComplexType() &&
    800          "Invalid complex expression to emit");
    801   ComplexExprEmitter Emitter(*this);
    802   ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
    803   Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile);
    804 }
    805 
    806 /// StoreComplexToAddr - Store a complex number into the specified address.
    807 void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V,
    808                                          llvm::Value *DestAddr,
    809                                          bool DestIsVolatile) {
    810   ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile);
    811 }
    812 
    813 /// LoadComplexFromAddr - Load a complex number from the specified address.
    814 ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr,
    815                                                    bool SrcIsVolatile) {
    816   return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile);
    817 }
    818 
    819 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
    820   assert(E->getOpcode() == BO_Assign);
    821   ComplexPairTy Val; // ignored
    822   return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
    823 }
    824 
    825 LValue CodeGenFunction::
    826 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
    827   ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &);
    828   switch (E->getOpcode()) {
    829   case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break;
    830   case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break;
    831   case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break;
    832   case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break;
    833 
    834   default:
    835     llvm_unreachable("unexpected complex compound assignment");
    836   }
    837 
    838   ComplexPairTy Val; // ignored
    839   return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
    840 }
    841