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