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