contrib/llvm/tools/clang/lib/CodeGen/CGExprComplex.cpp

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