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