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