CGExprComplex.cpp revision 7a7ee3033e44b45630981355460ef89efa0bdcc4
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 // Atomic to non-atomic casts may be more than a no-op for some platforms and 362 // for some types. 363 case CK_AtomicToNonAtomic: 364 case CK_NonAtomicToAtomic: 365 case CK_NoOp: 366 case CK_LValueToRValue: 367 case CK_UserDefinedConversion: 368 return Visit(Op); 369 370 case CK_LValueBitCast: { 371 llvm::Value *V = CGF.EmitLValue(Op).getAddress(); 372 V = Builder.CreateBitCast(V, 373 CGF.ConvertType(CGF.getContext().getPointerType(DestTy))); 374 // FIXME: Are the qualifiers correct here? 375 return EmitLoadOfComplex(V, DestTy.isVolatileQualified()); 376 } 377 378 case CK_BitCast: 379 case CK_BaseToDerived: 380 case CK_DerivedToBase: 381 case CK_UncheckedDerivedToBase: 382 case CK_Dynamic: 383 case CK_ToUnion: 384 case CK_ArrayToPointerDecay: 385 case CK_FunctionToPointerDecay: 386 case CK_NullToPointer: 387 case CK_NullToMemberPointer: 388 case CK_BaseToDerivedMemberPointer: 389 case CK_DerivedToBaseMemberPointer: 390 case CK_MemberPointerToBoolean: 391 case CK_ConstructorConversion: 392 case CK_IntegralToPointer: 393 case CK_PointerToIntegral: 394 case CK_PointerToBoolean: 395 case CK_ToVoid: 396 case CK_VectorSplat: 397 case CK_IntegralCast: 398 case CK_IntegralToBoolean: 399 case CK_IntegralToFloating: 400 case CK_FloatingToIntegral: 401 case CK_FloatingToBoolean: 402 case CK_FloatingCast: 403 case CK_CPointerToObjCPointerCast: 404 case CK_BlockPointerToObjCPointerCast: 405 case CK_AnyPointerToBlockPointerCast: 406 case CK_ObjCObjectLValueCast: 407 case CK_FloatingComplexToReal: 408 case CK_FloatingComplexToBoolean: 409 case CK_IntegralComplexToReal: 410 case CK_IntegralComplexToBoolean: 411 case CK_ARCProduceObject: 412 case CK_ARCConsumeObject: 413 case CK_ARCReclaimReturnedObject: 414 case CK_ARCExtendBlockObject: 415 llvm_unreachable("invalid cast kind for complex value"); 416 417 case CK_FloatingRealToComplex: 418 case CK_IntegralRealToComplex: { 419 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 420 421 // Convert the input element to the element type of the complex. 422 DestTy = DestTy->getAs<ComplexType>()->getElementType(); 423 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 424 425 // Return (realval, 0). 426 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 427 } 428 429 case CK_FloatingComplexCast: 430 case CK_FloatingComplexToIntegralComplex: 431 case CK_IntegralComplexCast: 432 case CK_IntegralComplexToFloatingComplex: 433 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 434 } 435 436 llvm_unreachable("unknown cast resulting in complex value"); 437} 438 439ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 440 TestAndClearIgnoreReal(); 441 TestAndClearIgnoreImag(); 442 ComplexPairTy Op = Visit(E->getSubExpr()); 443 444 llvm::Value *ResR, *ResI; 445 if (Op.first->getType()->isFloatingPointTy()) { 446 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 447 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 448 } else { 449 ResR = Builder.CreateNeg(Op.first, "neg.r"); 450 ResI = Builder.CreateNeg(Op.second, "neg.i"); 451 } 452 return ComplexPairTy(ResR, ResI); 453} 454 455ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 456 TestAndClearIgnoreReal(); 457 TestAndClearIgnoreImag(); 458 // ~(a+ib) = a + i*-b 459 ComplexPairTy Op = Visit(E->getSubExpr()); 460 llvm::Value *ResI; 461 if (Op.second->getType()->isFloatingPointTy()) 462 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 463 else 464 ResI = Builder.CreateNeg(Op.second, "conj.i"); 465 466 return ComplexPairTy(Op.first, ResI); 467} 468 469ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 470 llvm::Value *ResR, *ResI; 471 472 if (Op.LHS.first->getType()->isFloatingPointTy()) { 473 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 474 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 475 } else { 476 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 477 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 478 } 479 return ComplexPairTy(ResR, ResI); 480} 481 482ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 483 llvm::Value *ResR, *ResI; 484 if (Op.LHS.first->getType()->isFloatingPointTy()) { 485 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 486 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 487 } else { 488 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 489 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 490 } 491 return ComplexPairTy(ResR, ResI); 492} 493 494 495ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 496 using llvm::Value; 497 Value *ResR, *ResI; 498 499 if (Op.LHS.first->getType()->isFloatingPointTy()) { 500 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 501 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 502 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 503 504 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 505 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 506 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 507 } else { 508 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 509 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 510 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 511 512 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 513 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 514 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 515 } 516 return ComplexPairTy(ResR, ResI); 517} 518 519ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 520 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 521 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 522 523 524 llvm::Value *DSTr, *DSTi; 525 if (Op.LHS.first->getType()->isFloatingPointTy()) { 526 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 527 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c 528 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d 529 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd 530 531 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c 532 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d 533 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd 534 535 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c 536 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d 537 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad 538 539 DSTr = Builder.CreateFDiv(Tmp3, Tmp6); 540 DSTi = Builder.CreateFDiv(Tmp9, Tmp6); 541 } else { 542 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 543 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 544 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 545 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 546 547 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 548 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 549 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 550 551 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 552 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 553 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 554 555 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 556 DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 557 DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 558 } else { 559 DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 560 DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 561 } 562 } 563 564 return ComplexPairTy(DSTr, DSTi); 565} 566 567ComplexExprEmitter::BinOpInfo 568ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 569 TestAndClearIgnoreReal(); 570 TestAndClearIgnoreImag(); 571 BinOpInfo Ops; 572 Ops.LHS = Visit(E->getLHS()); 573 Ops.RHS = Visit(E->getRHS()); 574 Ops.Ty = E->getType(); 575 return Ops; 576} 577 578 579LValue ComplexExprEmitter:: 580EmitCompoundAssignLValue(const CompoundAssignOperator *E, 581 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 582 ComplexPairTy &Val) { 583 TestAndClearIgnoreReal(); 584 TestAndClearIgnoreImag(); 585 QualType LHSTy = E->getLHS()->getType(); 586 587 BinOpInfo OpInfo; 588 589 // Load the RHS and LHS operands. 590 // __block variables need to have the rhs evaluated first, plus this should 591 // improve codegen a little. 592 OpInfo.Ty = E->getComputationResultType(); 593 594 // The RHS should have been converted to the computation type. 595 assert(OpInfo.Ty->isAnyComplexType()); 596 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 597 E->getRHS()->getType())); 598 OpInfo.RHS = Visit(E->getRHS()); 599 600 LValue LHS = CGF.EmitLValue(E->getLHS()); 601 602 // Load from the l-value. 603 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS); 604 605 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 606 607 // Expand the binary operator. 608 ComplexPairTy Result = (this->*Func)(OpInfo); 609 610 // Truncate the result back to the LHS type. 611 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 612 Val = Result; 613 614 // Store the result value into the LHS lvalue. 615 EmitStoreThroughLValue(Result, LHS); 616 617 return LHS; 618} 619 620// Compound assignments. 621ComplexPairTy ComplexExprEmitter:: 622EmitCompoundAssign(const CompoundAssignOperator *E, 623 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 624 ComplexPairTy Val; 625 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 626 627 // The result of an assignment in C is the assigned r-value. 628 if (!CGF.getContext().getLangOptions().CPlusPlus) 629 return Val; 630 631 // If the lvalue is non-volatile, return the computed value of the assignment. 632 if (!LV.isVolatileQualified()) 633 return Val; 634 635 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 636} 637 638LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 639 ComplexPairTy &Val) { 640 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 641 E->getRHS()->getType()) && 642 "Invalid assignment"); 643 TestAndClearIgnoreReal(); 644 TestAndClearIgnoreImag(); 645 646 // Emit the RHS. __block variables need the RHS evaluated first. 647 Val = Visit(E->getRHS()); 648 649 // Compute the address to store into. 650 LValue LHS = CGF.EmitLValue(E->getLHS()); 651 652 // Store the result value into the LHS lvalue. 653 EmitStoreThroughLValue(Val, LHS); 654 655 return LHS; 656} 657 658ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 659 ComplexPairTy Val; 660 LValue LV = EmitBinAssignLValue(E, Val); 661 662 // The result of an assignment in C is the assigned r-value. 663 if (!CGF.getContext().getLangOptions().CPlusPlus) 664 return Val; 665 666 // If the lvalue is non-volatile, return the computed value of the assignment. 667 if (!LV.isVolatileQualified()) 668 return Val; 669 670 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 671} 672 673ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 674 CGF.EmitIgnoredExpr(E->getLHS()); 675 return Visit(E->getRHS()); 676} 677 678ComplexPairTy ComplexExprEmitter:: 679VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 680 TestAndClearIgnoreReal(); 681 TestAndClearIgnoreImag(); 682 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 683 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 684 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 685 686 // Bind the common expression if necessary. 687 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 688 689 CodeGenFunction::ConditionalEvaluation eval(CGF); 690 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 691 692 eval.begin(CGF); 693 CGF.EmitBlock(LHSBlock); 694 ComplexPairTy LHS = Visit(E->getTrueExpr()); 695 LHSBlock = Builder.GetInsertBlock(); 696 CGF.EmitBranch(ContBlock); 697 eval.end(CGF); 698 699 eval.begin(CGF); 700 CGF.EmitBlock(RHSBlock); 701 ComplexPairTy RHS = Visit(E->getFalseExpr()); 702 RHSBlock = Builder.GetInsertBlock(); 703 CGF.EmitBlock(ContBlock); 704 eval.end(CGF); 705 706 // Create a PHI node for the real part. 707 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 708 RealPN->addIncoming(LHS.first, LHSBlock); 709 RealPN->addIncoming(RHS.first, RHSBlock); 710 711 // Create a PHI node for the imaginary part. 712 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 713 ImagPN->addIncoming(LHS.second, LHSBlock); 714 ImagPN->addIncoming(RHS.second, RHSBlock); 715 716 return ComplexPairTy(RealPN, ImagPN); 717} 718 719ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 720 return Visit(E->getChosenSubExpr(CGF.getContext())); 721} 722 723ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 724 bool Ignore = TestAndClearIgnoreReal(); 725 (void)Ignore; 726 assert (Ignore == false && "init list ignored"); 727 Ignore = TestAndClearIgnoreImag(); 728 (void)Ignore; 729 assert (Ignore == false && "init list ignored"); 730 731 if (E->getNumInits() == 2) { 732 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 733 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 734 return ComplexPairTy(Real, Imag); 735 } else if (E->getNumInits() == 1) { 736 return Visit(E->getInit(0)); 737 } 738 739 // Empty init list intializes to null 740 assert(E->getNumInits() == 0 && "Unexpected number of inits"); 741 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType(); 742 llvm::Type* LTy = CGF.ConvertType(Ty); 743 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 744 return ComplexPairTy(zeroConstant, zeroConstant); 745} 746 747ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 748 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 749 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 750 751 if (!ArgPtr) { 752 CGF.ErrorUnsupported(E, "complex va_arg expression"); 753 llvm::Type *EltTy = 754 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 755 llvm::Value *U = llvm::UndefValue::get(EltTy); 756 return ComplexPairTy(U, U); 757 } 758 759 // FIXME Volatility. 760 return EmitLoadOfComplex(ArgPtr, false); 761} 762 763//===----------------------------------------------------------------------===// 764// Entry Point into this File 765//===----------------------------------------------------------------------===// 766 767/// EmitComplexExpr - Emit the computation of the specified expression of 768/// complex type, ignoring the result. 769ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 770 bool IgnoreImag) { 771 assert(E && E->getType()->isAnyComplexType() && 772 "Invalid complex expression to emit"); 773 774 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 775 .Visit(const_cast<Expr*>(E)); 776} 777 778/// EmitComplexExprIntoAddr - Emit the computation of the specified expression 779/// of complex type, storing into the specified Value*. 780void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 781 llvm::Value *DestAddr, 782 bool DestIsVolatile) { 783 assert(E && E->getType()->isAnyComplexType() && 784 "Invalid complex expression to emit"); 785 ComplexExprEmitter Emitter(*this); 786 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 787 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 788} 789 790/// StoreComplexToAddr - Store a complex number into the specified address. 791void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 792 llvm::Value *DestAddr, 793 bool DestIsVolatile) { 794 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 795} 796 797/// LoadComplexFromAddr - Load a complex number from the specified address. 798ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 799 bool SrcIsVolatile) { 800 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 801} 802 803LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 804 assert(E->getOpcode() == BO_Assign); 805 ComplexPairTy Val; // ignored 806 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 807} 808 809LValue CodeGenFunction:: 810EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 811 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &); 812 switch (E->getOpcode()) { 813 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break; 814 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break; 815 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break; 816 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break; 817 818 default: 819 llvm_unreachable("unexpected complex compound assignment"); 820 Op = 0; 821 } 822 823 ComplexPairTy Val; // ignored 824 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 825} 826